Thoughts of Algorithms

# config/scoring/pipeline_judge.yaml
dimensions:
  - name: correctness
    file: correctness
    weight: 1.2
    extra_data: { parser: numeric }

  - name: feasibility
    file: feasibility
    weight: 1.1
    extra_data: { parser: numeric }

  - name: insightfulness
    file: insightfulness
    weight: 1.3
    extra_data: { parser: numeric }

  - name: alignment
    file: alignment
    weight: 1.0
    extra_data: { parser: numeric }

  - name: clarity
    file: clarity
    weight: 1.1
    extra_data: { parser: numeric }

# Example usage:
tuner = ContrastiveDimensionalTuner(dimensions=["correctness", "clarity", "originality"])

# Add training data
tuner.add_training_pair(
    scores_a={"correctness": 0.9, "clarity": 0.8, "originality": 0.6},
    scores_b={"correctness": 0.7, "clarity": 0.9, "originality": 0.5},
    preferred="A"
)

tuner.train()

# Use learned weights
print(tuner.get_weights())

class ContrastiveDimensionalTuner:
    """
    Learns weights for each scoring dimension using contrastive learning.
    Given pairs of scored examples (A vs B) and a preference, it learns which dimensions matter most.
    """

    def __init__(self, dimensions, logger=None):
        """
        Args:
            dimensions (list of str): List of dimension names (e.g., ["correctness", "clarity"]).
            logger (optional): Optional logger to record training events.
        """
        self.dimensions = dimensions
        self.logger = logger
        self.X = []  # Feature differences (vector of deltas across dimensions)
        self.y = []  # Labels: 1 if A preferred over B, 0 otherwise
        self.model = None

    def add_training_pair(self, scores_a: dict, scores_b: dict, preferred: str):
        """
        Adds a training example.

        Args:
            scores_a (dict): Scores for option A, keyed by dimension.
            scores_b (dict): Scores for option B, keyed by dimension.
            preferred (str): "A" or "B", indicating which output was preferred.
        """
        delta = np.array([
            scores_a[dim] - scores_b[dim] for dim in self.dimensions
        ])

        # If B is preferred, invert the delta
        if preferred.upper() == "B":
            delta = -delta
            label = 1  # B preferred (inverted delta)
        else:
            label = 1  # A preferred (original delta)

        self.X.append(delta)
        self.y.append(label)

        if self.logger:
            self.logger.log("ContrastiveTrainingPairAdded", {
                "delta": delta.tolist(),
                "preferred": preferred
            })

    def train(self):
        """
        Trains a logistic regression model using the current contrastive data.
        """
        if len(self.X) < 3:
            if self.logger:
                self.logger.log("ContrastiveTrainingSkipped", {
                    "reason": "Not enough data",
                    "num_examples": len(self.X)
                })
            return

        X_array = np.array(self.X)
        y_array = np.array(self.y)

        self.model = LogisticRegression()
        self.model.fit(X_array, y_array)

        if self.logger:
            self.logger.log("ContrastiveModelTrained", {
                "coefficients": self.get_weights()
            })

    def get_weights(self) -> dict:
        """
        Returns the learned dimension weights (if trained).

        Returns:
            dict: Mapping from dimension to learned weight.
        """
        if self.model is None:
            return {dim: 1.0 for dim in self.dimensions}  # fallback: equal weights

        weights = self.model.coef_[0]
        return {
            dim: round(float(w), 4) for dim, w in zip(self.dimensions, weights)
        }

    def score(self, dimension_scores: dict) -> float:
        """
        Calculates a single weighted score from per-dimension scores.

        Args:
            dimension_scores (dict): Scores keyed by dimension.

        Returns:
            float: Weighted total score.
        """
        weights = self.get_weights()
        total = sum(dimension_scores[dim] * weights.get(dim, 1.0) for dim in self.dimensions)
        return round(total, 4)

if dimension not in self.models:
    self._initialize_dimension(dimension)

tuned = tuner.transform(norm_score)

zsa = encoder(prompt_emb, response_emb)
raw_score = predictor(zsa).item()

            WITH scored_prompts AS (
                SELECT
                    s.dimension,
                    s.score,
                    e.pipeline_run_id,
                    p.id AS prompt_id,
                    p.prompt_text,
                    p.response_text,
                    ROW_NUMBER() OVER (
                        PARTITION BY s.dimension, p.id ORDER BY s.score DESC
                    ) AS rank_high,
                    ROW_NUMBER() OVER (
                        PARTITION BY s.dimension, p.id ORDER BY s.score ASC
                    ) AS rank_low
                FROM scores s
                JOIN evaluations e ON s.evaluation_id = e.id
                JOIN prompts p ON e.pipeline_run_id = p.pipeline_run_id
                WHERE s.score IS NOT NULL
                {goal_filter}
            )
            SELECT
                dimension,
                prompt_text,
                response_text,
                score,
                rank_type
            FROM (
                SELECT
                    dimension,
                    prompt_text,
                    response_text,
                    score,
                    'top' AS rank_type,
                    prompt_id
                FROM scored_prompts
                WHERE rank_high = 1
                  AND prompt_text IS NOT NULL
                  AND response_text IS NOT NULL
                  AND prompt_text <> ''
                  AND response_text  <> ''
                  
                UNION ALL

                SELECT
                    dimension,
                    prompt_text,
                    response_text,
                    score,
                    'bottom' AS rank_type,
                    prompt_id
                FROM scored_prompts
                WHERE rank_low = 1
            ) AS ranked_pairs
            ORDER BY dimension, prompt_id
            LIMIT :limit

class MRQScorer(BaseScorer):
    def __init__(self, cfg: dict, memory, logger, dimensions=None):
        self.cfg = cfg
        self.memory = memory
        self.logger = logger
        self.device = cfg.get("device", "cpu")
        self.dimensions = dimensions or ["mrq"]
        self.models = {}  # dim -> (encoder, predictor)
        self.trainers = {}
        self.min_score_by_dim = {}
        self.max_score_by_dim = {}
        self.value_predictor = HypothesisValuePredictor(512, 1024).to(self.device)
        self.encoder = TextEncoder().to(self.device)
        self.regression_tuners = {}

        # Initialize model + tuner for each dimension
        for dim in self.dimensions:
            self.regression_tuners[dim] = RegressionTuner(
                dimension=dim, logger=self.logger
            )
            trainer = MRQTrainer(
                memory=memory,
                logger=logger,
                value_predictor=self.value_predictor,
                encoder=self.encoder,
                device=self.device,
            )
            self.models[dim] = (self.encoder, self.value_predictor)
            self.trainers[dim] = trainer
            self.min_score_by_dim[dim] = 0.0
            self.max_score_by_dim[dim] = 1.0

    def score(self, goal: dict, hypothesis: dict, dimensions: list[str]) -> ScoreBundle:
        """
        Predicts scores for given dimensions using MR.Q and applies tuning if available.
        """
        results = []
        for dim in dimensions:
            score = self._estimate_score(goal, hypothesis, dim)
            rationale = f"MRQ estimated score for {dim}."
            self.logger.log(
                "MRQDimensionEvaluated",
                {"dimension": dim, "score": score, "rationale": rationale},
            )
            results.append(
                ScoreResult(
                    dimension=dim,
                    score=score,
                    rationale=rationale,
                    weight=1.0,
                    source="mrq",
                )
            )
        return ScoreBundle(results={r.dimension: r for r in results})

    def _estimate_score(self, goal, hypothesis, dimension):
        """
        Core logic: compute embeddings, run prediction, apply optional regression tuner.
        """
        # Initialize dimension on demand
        if dimension not in self.models:
            self._initialize_dimension(dimension)

        prompt_emb = torch.tensor(
            self.memory.embedding.get_or_create(goal.get("goal_text")),
            device=self.device,
        ).unsqueeze(0)
        response_emb = torch.tensor(
            self.memory.embedding.get_or_create(hypothesis.get("text")),
            device=self.device,
        ).unsqueeze(0)

        encoder, predictor = self.models[dimension]
        zsa = encoder(prompt_emb, response_emb)
        raw_score = predictor(zsa).item()
        norm_score = self.normalize_score(raw_score, dimension)

        # Optionally apply tuner
        tuner = self.regression_tuners.get(dimension)
        if tuner:
            tuned = tuner.transform(norm_score)
            self.logger.log(
                "MRQTunedScore",
                {"dimension": dimension, "raw": norm_score, "tuned": tuned},
            )
            return tuned
        return norm_score

    def _initialize_dimension(self, dimension):
        self.regression_tuners[dimension] = RegressionTuner(
            dimension=dimension, logger=self.logger
        )
        self.trainers[dimension] = MRQTrainer(
            memory=self.memory, logger=self.logger, value_predictor=self.value_predictor, encoder=self.encoder, device=self.device
        )
        self.models[dimension] = (self.encoder, self.value_predictor)
        self.min_score_by_dim[dimension] = 0.0
        self.max_score_by_dim[dimension] = 1.0
        self.logger.log("MRQModelInitializing", {"dimension": dimension})

    def align_to_best_llm_neighbour(self, goal, hypothesis, dimension):
        """
        Fetch similar hypotheses that already have high LLM scores.
        Then align MR.Q prediction to the best of them.
        """
        llm_scores = self.get_closest_llm_scores(hypothesis["text"], dimension)
        if llm_scores:
            self.align_with_llm_score(dimension, goal, hypothesis, max(llm_scores))

    def get_closest_llm_scores(
        self, hypothesis_text: str, dimension: str, top_k: int = 5
    ) -> list[float]:
        """
        Finds the top_k LLM scores for hypotheses most similar to the given one.
        """
        query_emb = self.memory.embedding.get_or_create(hypothesis_text)
        similar_items = self.memory.embedding.similarity_search(query_emb, top_k)

        scores = []
        for item in similar_items:
            matched_text = item.get("text")
            score_entry = self.memory.score.find_by_text_and_dimension(
                matched_text, dimension=dimension, source="llm"
            )
            if score_entry:
                scores.append(score_entry.score)
        return scores

    def align_with_llm_score(self, dimension, goal, hypothesis, llm_score):
        mrq_score = self._estimate_score(goal, hypothesis, dimension)
        self.logger.log(
            "MRQAligningToLLM",
            {
                "goal": goal.get("goal_text"),
                "hypothesis": hypothesis.get("text"),
                "dimension": dimension,
                "mrq_raw": mrq_score,
                "llm_target": llm_score,
            },
        )
        self.regression_tuners[dimension].add_example(mrq_score, llm_score)
        self.logger.log(
            "MRQAlignmentAdded",
            {
                "dimension": dimension,
                "example_count": len(self.regression_tuners[dimension].examples),
            },
        )

    def evaluate(self, prompt: str, response: str) -> ScoreBundle:
        """
        Scores a prompt-response pair across all dimensions, and saves it.
        """
        results = []
        for dim, (encoder, predictor) in self.models.items():
            prompt_emb = torch.tensor(
                self.memory.embedding.get_or_create(prompt), device=self.device
            ).unsqueeze(0)
            output_emb = torch.tensor(
                self.memory.embedding.get_or_create(response), device=self.device
            ).unsqueeze(0)
            zsa = encoder(prompt_emb, output_emb)
            value = predictor(zsa).item()
            norm_score = self.normalize_score(value, dim)

            results.append(
                ScoreResult(
                    dimension=dim,
                    score=norm_score,
                    weight=1.0,
                    rationale=f"MR.Q model trained for {dim}",
                    source="mrq",
                )
            )

        bundle = ScoreBundle(results={r.dimension: r for r in results})
        ScoringManager.save_score_to_memory(
            bundle,
            response,
            cfg=self.cfg,
            memory=self.memory,
            logger=self.logger,
            source="mrq",
        )
        return bundle

    def normalize_score(self, raw, dim):
        min_ = self.min_score_by_dim.get(dim, 0.0)
        max_ = self.max_score_by_dim.get(dim, 1.0)
        return round(100 * (raw - min_) / (max_ - min_ or 1.0), 2)

    def judge(self, goal, prompt, output_a, output_b):
        """
        Compares two outputs via MR.Q and returns the preferred one.
        """
        dim = self.dimensions[0]
        encoder, predictor = self.models[dim]

        prompt_emb = torch.tensor(
            self.memory.embedding.get_or_create(prompt), device=self.device
        ).unsqueeze(0)
        a_emb = torch.tensor(
            self.memory.embedding.get_or_create(output_a), device=self.device
        ).unsqueeze(0)
        b_emb = torch.tensor(
            self.memory.embedding.get_or_create(output_b), device=self.device
        ).unsqueeze(0)

        value_a = predictor(encoder(prompt_emb, a_emb)).item()
        value_b = predictor(encoder(prompt_emb, b_emb)).item()
        preferred = output_a if value_a >= value_b else output_b

        # Optionally log sharpening example
        if self.memory.mrq.log_evaluations():
            pred = SharpeningPredictionORM(
                id=None,
                goal_id=-1,
                prompt_text=prompt,
                output_a=output_a,
                output_b=output_b,
                preferred="a" if value_a >= value_b else "b",
                predicted="a" if value_a >= value_b else "b",
                value_a=value_a,
                value_b=value_b,
            )
            self.memory.sharpening.insert_sharpening_prediction(pred.to_dict(), goal)

        return preferred, {"value_a": value_a, "value_b": value_b}

    def train_from_database(self, cfg: dict):
        all_samples = self.memory.mrq.get_training_pairs_by_dimension()
        for dim, samples in all_samples.items():
            if not samples:
                self.logger.log("MRQNoTrainingSamples", {"dimension": dim})
                continue

            self.align_mrq_with_llm_scores_from_pairs(samples, dimension=dim)

            self.logger.log(
                "MRQTrainingStart", {"dimension": dim, "sample_count": len(samples)}
            )

            if dim not in self.trainers:
                self.trainers[dim] = MRQTrainer(
                    memory=self.memory,
                    logger=self.logger,
                    encoder=self.encoder,
                    value_predictor=self.value_predictor,
                    device=self.device,
                )

            self.update_score_bounds_from_data(samples, dim)
            dataloader = self.trainers[dim].prepare_training_data(samples)
            self.trainers[dim].train(dataloader, cfg)

            self.logger.log("MRQTrainingComplete", {"dimension": dim})

    def train_from_context(self, context: dict, cfg: dict):
        dim_samples = context.get("mrq_training_pairs_by_dimension", {})
        for dim, samples in dim_samples.items():
            if not samples:
                self.logger.log("MRQNoTrainingFromContext", {"dimension": dim})
                continue

            self.logger.log(
                "MRQContextTrainingStart",
                {"dimension": dim, "sample_count": len(samples)},
            )

            self.update_score_bounds_from_data(samples, dim)
            dataloader = self.trainers[dim].prepare_training_data(samples)
            self.trainers[dim].train(dataloader, cfg)

            self.logger.log("MRQContextTrainingComplete", {"dimension": dim})

    def update_score_bounds_from_data(self, samples: list, dim: str):
        values = []
        for s in samples:
            if "value_a" in s and "value_b" in s:
                values.extend([s["value_a"], s["value_b"]])
            elif "value" in s:
                values.append(s["value"])
        if values:
            min_score = min(values)
            max_score = max(values)
            self.min_score_by_dim[dim] = min_score
            self.max_score_by_dim[dim] = max_score
            self.logger.log(
                "MRQScoreBoundsUpdated",
                {
                    "dimension": dim,
                    "min_score": min_score,
                    "max_score": max_score,
                    "example_count": len(values),
                },
            )

    def align_mrq_with_llm_scores_from_pairs(
        self, pair_samples: list[dict], dimension: str, log_prefix: str = "MRQAlignment"
    ):
        for pair in pair_samples:
            prompt = pair["prompt"]
            for side in ["a", "b"]:
                hyp = pair[f"output_{side}"]
                llm_score = pair[f"value_{side}"]

                # Predict MRQ score dynamically
                mrq_score = self.score(
                    {"goal_text": prompt}, {"text": hyp}, [dimension]
                )

                # Log the alignment
                self.logger.log(
                    f"{log_prefix}Dynamic",
                    {
                        "prompt_hash": hash(prompt),
                        "hypothesis_hash": hash(hyp),
                        "dimension": dimension,
                        "llm_score": llm_score,
                        "predicted_mrq": mrq_score,
                    },
                )

                # Pass the pair into the regression tuner
                if mrq_score is not None and llm_score is not None:
                    self.regression_tuners[dimension].train_single(
                        mrq_score=mrq_score.results[dimension].score,
                        llm_score=llm_score,
                    )

class SVMScorer(BaseScorer):
    def __init__(self, cfg: dict, memory, logger, dimensions=None):
        self.cfg = cfg
        self.memory = memory
        self.logger = logger
        self.dimensions = dimensions or ["alignment"]
        self.models = {dim: SVR() for dim in self.dimensions}
        self.scalers = {dim: StandardScaler() for dim in self.dimensions}
        self.trained = {dim: False for dim in self.dimensions}
        self.regression_tuners = {}  
        for dim in self.dimensions:
            self._initialize_dimension(dim)

    def _initialize_dimension(self, dim):
        self.models[dim] = SVR()
        self.scalers[dim] = StandardScaler()
        self.trained[dim] = False
        self.regression_tuners[dim] = RegressionTuner(dimension=dim, logger=self.logger)

    def train(self, samples_by_dim: dict[str, list[dict]]):
        """
        Train per-dimension SVM from labeled LLM/MRQ training data
        """
        for dim, samples in samples_by_dim.items():
            x = []
            y = []
            for sample in samples:
                prompt = sample["prompt"]
                hyp = sample["output"]
                score = sample["value"]
                feat = self._build_feature_vector({"goal_text": prompt}, {"text": hyp})
                x.append(feat)
                y.append(score)

            x = np.array(x)
            y = np.array(y)
            self.scalers[dim].fit(x)
            x_scaled = self.scalers[dim].transform(x)

            self.models[dim].fit(x_scaled, y)
            self.trained[dim] = True

            self.logger.log("SVMTrainingComplete", {
                "dimension": dim,
                "samples": len(samples),
                "score_min": float(np.min(y)),
                "score_max": float(np.max(y)),
            })

    def _build_feature_vector(self, goal: dict, hypothesis: dict):
        """
        Basic feature vector: concat prompt + hypothesis embeddings + MRQ raw score (if available)
        """
        emb_goal = self.memory.embedding.get_or_create(goal["goal_text"])
        emb_hyp = self.memory.embedding.get_or_create(hypothesis["text"])
        vec = emb_goal + emb_hyp

        # Optional MRQ bridge feature
        mrq = self.memory.score.find_by_text_and_dimension(
            hypothesis["text"], dimension="alignment", source="mrq"
        )
        if mrq:
            vec.append(mrq.score / 100.0)  # normalized to [0,1]
        else:
            vec.append(0.5)  # neutral if no MRQ score

        return vec

    def train_from_database(self):
        pair_samples = self.memory.mrq.get_training_pairs_by_dimension()
        samples_by_dim = self.convert_mrq_pairs_to_supervised_examples(pair_samples)

        for dim, examples in samples_by_dim.items():
            self.train_for_dimension(dim, examples)


    def convert_mrq_pairs_to_supervised_examples(self, pair_samples: list[dict]) -> dict[str, list[dict]]:
        """
        Converts MRQ-style contrastive training pairs into a flat list of (prompt, output, value)
        entries per dimension, suitable for supervised regression training.
        """
        per_dimension = defaultdict(list)
        for pair in pair_samples:
            dim = pair.get("dimension", "default")

            for side in ["a", "b"]:
                output = pair.get(f"output_{side}")
                score = pair.get(f"value_{side}")
                if output is not None and score is not None:
                    per_dimension[dim].append({
                        "prompt": pair["prompt"],
                        "output": output,
                        "value": score
                    })

        self.logger.log("SVMConvertedMRQPacks", {
            "dimensions": list(per_dimension.keys()),
            "total_samples": sum(len(v) for v in per_dimension.values())
        })

        return per_dimension

    def train_for_dimension(self, dimension: str, examples: list[dict]):
        X = []
        y = []
        for ex in examples:
            prompt_vec = self.memory.embedding.get_or_create(ex["prompt"])
            output_vec = self.memory.embedding.get_or_create(ex["output"])
            pair_vec = np.array(prompt_vec + output_vec)
            X.append(pair_vec)
            y.append(ex["value"])

        X = np.array(X)
        y = np.array(y)

        scaler = StandardScaler()
        X_scaled = scaler.fit_transform(X)

        model = SVR(kernel="linear")  # you can adjust kernel if needed
        model.fit(X_scaled, y)

        self.models[dimension] = (scaler, model)

        self.logger.log("SVMModelTrained", {
            "dimension": dimension,
            "num_samples": len(y)
        })

    def score(self, goal: dict, hypothesis: dict, dimensions: list[str]) -> ScoreBundle:
        results = {}
        for dim in dimensions:
            vec = self._build_feature_vector(goal, hypothesis)

            # Dynamic training if needed
            if not self.trained[dim]:
                self._try_train_on_dimension(dim)

            if not self.trained[dim]:
                score = 50.0
                rationale = f"SVM not trained for {dim}, returning neutral."
            else:
                x = self.scalers[dim].transform([vec])
                raw_score = self.models[dim].predict(x)[0]
                tuned_score = self.regression_tuners[dim].transform(raw_score)
                score = tuned_score
                rationale = f"SVM predicted and aligned score for {dim}"

            self.logger.log("SVMScoreComputed", {
                "dimension": dim,
                "score": score,
                "hypothesis": hypothesis.get("text"),
            })

            results[dim] = ScoreResult(
                dimension=dim,
                score=score,
                rationale=rationale,
                weight=1.0,
                source="svm",
            )

        return ScoreBundle(results=results)

    def _try_train_on_dimension(self, dim):
        samples_by_dim = self.memory.mrq.get_training_pairs_by_dimension()
        samples = samples_by_dim.get(dim, [])
        if not samples:
            self.logger.log("SVMNoSamples", {"dimension": dim})
            return

        X, y = [], []
        for s in samples:
            for side in ["a", "b"]:
                prompt = s["prompt"]
                hypothesis = s[f"output_{side}"]
                llm_score = s.get(f"value_{side}")
                if prompt and hypothesis and llm_score is not None:
                    vec = self._build_feature_vector({"goal_text": prompt}, {"text": hypothesis})
                    X.append(vec)
                    y.append(llm_score)
                    self.regression_tuners[dim].add_example(llm_score, llm_score)  # no-op, self-alignment fallback

        if not X:
            return

        X_scaled = self.scalers[dim].fit_transform(X)
        self.models[dim].fit(X_scaled, y)
        self.trained[dim] = True

        self.logger.log("SVMTrainingComplete", {
            "dimension": dim,
            "samples": len(X)
        })

        # Align the scores using same logic as MRQ
        self._align_with_llm(samples, dim)

    def _align_with_llm(self, samples, dim):
        for s in samples:
            for side in ["a", "b"]:
                prompt = s["prompt"]
                hypothesis = s[f"output_{side}"]
                llm_score = s.get(f"value_{side}")
                if llm_score is None:
                    continue

                vec = self._build_feature_vector({"goal_text": prompt}, {"text": hypothesis})
                x = self.scalers[dim].transform([vec])
                raw_score = self.models[dim].predict(x)[0]

                self.regression_tuners[dim].train_single(mrq_score=raw_score, llm_score=llm_score)

                self.logger.log("SVMAlignmentDynamic", {
                    "dimension": dim,
                    "mrq_score": raw_score,
                    "llm_score": llm_score
                })    


    def _train_dimension(self, dim: str):
        pairs_by_dim = self.memory.mrq.get_training_pairs_by_dimension()
        samples = pairs_by_dim.get(dim, [])
        if not samples:
            self.logger.log("SVMNoTrainingData", {"dimension": dim})
            self.trained[dim] = False
            return

        X = []
        y = []
        for sample in samples:
            goal = {"goal_text": sample["prompt"]}
            for side in ["a", "b"]:
                hyp = {"text": sample[f"output_{side}"]}
                label = sample.get(f"value_{side}")
                if label is not None:
                    vec = self._build_feature_vector(goal, hyp)
                    X.append(vec)
                    y.append(label)

        if len(X) < 5:
            self.logger.log("SVMInsufficientTrainingData", {"dimension": dim, "count": len(X)})
            self.trained[dim] = False
            return

        X_scaled = self.scalers[dim].fit_transform(X)
        self.models[dim].fit(X_scaled, y)
        self.trained[dim] = True
        self.logger.log("SVMTrained", {"dimension": dim, "samples": len(X)})

MR.Q score → 0.68  
LLM score → 0.84

raw score: 0.68 → tuned score: 0.81

class RegressionTuner:
    """
    Learns to transform MR.Q scores to align with LLM scores dynamically.
    Does not save any state to disk purely in-memory and real-time.
    """

    def __init__(self, dimension: str, logger=None, min_samples: int = 10):
        self.dimension = dimension
        self.logger = logger
        self.min_samples = min_samples
        self.x = []  # MRQ scores
        self.y = []  # LLM scores
        self.model = None

    def train_single(self, mrq_score: float, llm_score: float):
        """Adds a new training pair and refits if threshold reached."""
        self.x.append(mrq_score)
        self.y.append(llm_score)

        if len(self.x) >= self.min_samples:
            self._fit()

        if self.logger:
            self.logger.log("RegressionTunerTrainSingle", {
                "dimension": self.dimension,
                "mrq_score": mrq_score,
                "llm_score": llm_score,
                "total_samples": len(self.x)
            })

    def _fit(self):
        """Fits a linear regression model to current examples."""
        x_arr = np.array(self.x).reshape(-1, 1)
        y_arr = np.array(self.y)

        self.model = LinearRegression().fit(x_arr, y_arr)

        if self.logger:
            self.logger.log("RegressionTunerFitted", {
                "dimension": self.dimension,
                "count": len(self.x),
                "coef": float(self.model.coef_[0]),
                "intercept": float(self.model.intercept_),
            })

    def transform(self, score: float) -> float:
        """Transforms a score using the fitted regression model if available."""
        if self.model:
            return float(self.model.predict(np.array([[score]]))[0])
        return score

agent_name: HypothesisGenerator
metadata_filter:
  goal_type: scientific
override:
  model: mistral
  prompt: cot_enhanced.j2
  scorer: meta_review

{
  "rule_id": "rule-123",
  "pipeline_run_id": "run-789",
  "agent_name": "HypothesisGenerator",
  "context_hash": "abc123",
  "overrides": {
    "model": "mistral",
    "prompt": "cot_enhanced.j2"
  }
}

class SymbolicRuleApplier:
    def __init__(self, cfg, memory, logger):
        self.cfg = cfg
        self.memory = memory
        self.logger = logger
        self.enabled = cfg.get("symbolic", {}).get("enabled", False)
        self._rules = self._load_rules() if self.enabled else []

    @property
    def rules(self) -> list:
        return self._rules
    
    def apply(self, context: dict) -> dict:
        if not self.enabled:
            return context

        goal = context.get("goal", {})
        pipeline_run_id = context.get("pipeline_run_id")
        current_pipeline = context.get("pipeline", [])

        matching_rules = [r for r in self.rules if self._matches_metadata(r, goal)]

        if not matching_rules:
            self.logger.log("NoSymbolicRulesApplied", {"goal_id": goal.get("id")})
            return context

        self.logger.log("SymbolicRulesFound", {"count": len(matching_rules)})

        for rule in matching_rules:
            if rule.rule_text and "pipeline:" in rule.rule_text:
                suggested_pipeline = (
                    rule.rule_text.split("pipeline:")[-1].strip().split(",")
                )
                suggested_pipeline = [
                    s.strip() for s in suggested_pipeline if s.strip()
                ]
                if suggested_pipeline:
                    self.logger.log(
                        "PipelineUpdatedBySymbolicRule",
                        {
                            "from": current_pipeline,
                            "to": suggested_pipeline,
                            "rule_id": rule.id,
                        },
                    )
                    context["pipeline"] = suggested_pipeline
                    context["pipeline_updated_by_symbolic_rule"] = True

            if rule.source == "lookahead" and rule.goal_type:
                context["symbolic_hint"] = f"use_{rule.goal_type.lower()}_strategy"

        return context

    def apply_to_agent(self, cfg: Dict, context: Dict) -> Dict:
        if not self.enabled:
            return cfg

        goal = context.get("goal", {})
        pipeline_run_id = context.get("pipeline_run_id")
        agent_name = cfg.get("name")

        matching_rules = [
            r
            for r in self.rules
            if r.agent_name == agent_name and self._matches_metadata(r, goal)
        ]

        if not matching_rules:
            self.logger.log(
                "NoSymbolicAgentRulesApplied",
                {
                    "agent": agent_name,
                    "goal_id": goal.get("id"),
                },
            )
            return cfg

        self.logger.log(
            "SymbolicAgentRulesFound",
            {
                "agent": agent_name,
                "goal_id": goal.get("id"),
                "count": len(matching_rules),
            },
        )

        for rule in matching_rules:
            # Apply new-style attributes
            if rule.attributes:
                for key, value in rule.attributes.items():
                    if key in cfg:
                        self.logger.log(
                            "SymbolicAgentOverride",
                            {
                                "agent": agent_name,
                                "key": key,
                                "old_value": cfg[key],
                                "new_value": value,
                                "rule_id": rule.id,
                            },
                        )
                    else:
                        self.logger.log(
                            "SymbolicAgentNewKey",
                            {
                                "agent": agent_name,
                                "key": key,
                                "value": value,
                                "rule_id": rule.id,
                            },
                        )
                    cfg[key] = value

            # Apply legacy rule_text (optional, for backward compatibility)
            if rule.rule_text:
                entries = [e.strip() for e in rule.rule_text.split(",") if e.strip()]
                for entry in entries:
                    if ":" in entry:
                        key, value = [s.strip() for s in entry.split(":", 1)]
                        if key in cfg:
                            self.logger.log(
                                "SymbolicAgentOverride",
                                {
                                    "agent": agent_name,
                                    "key": key,
                                    "old_value": cfg[key],
                                    "new_value": value,
                                    "rule_id": rule.id,
                                },
                            )
                        else:
                            self.logger.log(
                                "SymbolicAgentNewKey",
                                {
                                    "agent": agent_name,
                                    "key": key,
                                    "value": value,
                                    "rule_id": rule.id,
                                },
                            )
                        cfg[key] = value

            # Record the application of this rule
            self.memory.rule_effects.insert(
                goal_id=goal.get("id"),
                agent_name=agent_name,
                rule_id=rule.id,
                pipeline_run_id=pipeline_run_id,
                details=rule.to_dict(),
                stage_details=cfg,
            )

        return cfg


    def apply_prompt_rules(
            self, agent_name: str, prompt_cfg: dict, context: dict
        ) -> dict:
        """
        Applies prompt-level symbolic rules to the prompt config before generation.

        Returns the updated prompt_cfg.
        """
        goal = context.get("goal", {})
        applicable_rules = [
            rule
            for rule in self.rules
            if rule.agent_name == agent_name
            # and self._matches_filter(rule.filter, goal)
        ]

        if not applicable_rules:
            self.logger.log("NoPromptRulesFound", {"agent": agent_name})
            return prompt_cfg

        for rule in applicable_rules:
            for key, value in rule.attributes.items():
                self.logger.log(
                    "PromptAttributeOverride",
                    {
                        "agent": agent_name,
                        "key": key,
                        "old_value": prompt_cfg.get(key),
                        "new_value": value,
                        "rule_id": rule.id,
                        "emoji": "🛠️",
                    },
                )
                self.set_nested(prompt_cfg, key, value)

            # Optional: record the rule application
            self.memory.rule_effects.insert(
                rule_id=rule.id,
                goal_id=goal.get("id"),
                pipeline_run_id=context.get("pipeline_run_id"),
                details=prompt_cfg,
            )

        return prompt_cfg

    def set_nested(self, cfg: dict, dotted_key: str, value):
        keys = dotted_key.split(".")
        d = cfg
        for k in keys[:-1]:
            if k not in d or not isinstance(d[k], dict):
                d[k] = {}
            d = d[k]
        d[keys[-1]] = value

    def apply_to_prompt(self, cfg: Dict, context: Dict) -> Dict:
        if not self.enabled:
            return cfg

        goal = context.get("goal", {})
        pipeline_run_id = context.get("pipeline_run_id")
        prompt_name = cfg.get("prompt_key", "unknown_prompt")

        matching_rules = [
            r for r in self.rules
            if r.target == "prompt" and self._matches_filter(r.filter, goal)
        ]

        if not matching_rules:
            self.logger.log("NoSymbolicPromptRulesApplied", {
                "prompt": prompt_name,
                "goal_id": goal.get("id"),
            })
            return cfg

        self.logger.log("SymbolicPromptRulesFound", {
            "prompt": prompt_name,
            "goal_id": goal.get("id"),
            "count": len(matching_rules),
        })

        for rule in matching_rules:
            for key, value in rule.attributes.items():
                if key in cfg:
                    self.logger.log("SymbolicPromptOverride", {
                        "prompt": prompt_name,
                        "key": key,
                        "old_value": cfg[key],
                        "new_value": value,
                        "rule_id": rule.id,
                    })
                else:
                    self.logger.log("SymbolicPromptNewKey", {
                        "prompt": prompt_name,
                        "key": key,
                        "value": value,
                        "rule_id": rule.id,
                    })
                cfg[key] = value

            # Track the application of the prompt-level rule
            self.memory.rule_effects.insert(
                rule_id=rule.id,
                goal_id=goal.get("id"),
                pipeline_run_id=pipeline_run_id,
                agent_name=cfg.get("name", "prompt"),
                context_hash=self.compute_context_hash(context),
                run_id=context.get("run_id"),
            )

        return cfg

    def _matches_filter(self, filter_dict: dict, target_obj: dict) -> bool:
        """Generic matcher for symbolic rule filters"""
        for key, value in filter_dict.items():
            target_value = target_obj.get(key)
            if isinstance(value, list):
                if target_value not in value:
                    return False
            else:
                if target_value != value:
                    return False
        return True

    def track_pipeline_stage(self, stage_dict: dict, context: dict):
        self.memory.symbolic_rules.track_pipeline_stage(stage_dict, context)

    def get_nested_value(d, key_path: str):
        keys = key_path.split(".")
        for key in keys:
            d = d.get(key, {})
        return d if d else None

    def set_nested_value(d, key_path: str, value):
        keys = key_path.split(".")
        for key in keys[:-1]:
            d = d.setdefault(key, {})
        d[keys[-1]] = value

    def _load_rules(self):
        rules = []
        symbolic_dict = self.cfg.get("symbolic", {})
        if symbolic_dict.get("rules_file"):
            rules += self._load_rules_from_yaml(symbolic_dict.get("rules_file"))
        if symbolic_dict.get("enable_db_rules", True):
            rules += self.memory.symbolic_rules.get_all_rules()
        return rules

    def _load_rules_from_yaml(self, path: str) -> list:
        if not Path(path).exists():
            self.logger.log("SymbolicRuleYAMLNotFound", {"path": path})
            return []

        with open(path, "r", encoding="utf-8") as f:
            raw = yaml.safe_load(f)

        rules_list = raw.get("rules", raw)

        rules = []
        existing_rules = {
            r.rule_text for r in self.memory.symbolic_rules.get_all_rules()
        }
        for item in rules_list:
            if isinstance(item, dict) and item.get("rule_text") not in existing_rules:
                rules.append(SymbolicRuleORM(**item))
            else:
                self.logger.log(
                    "DuplicateSymbolicRuleSkipped", {"rule_text": item.get("rule_text")}
                )
        return rules

    def _matches_metadata(self, rule: SymbolicRuleORM, goal: Dict[str, Any]) -> bool:
        if rule.goal_id and rule.goal_id != goal.get("id"):
            return False
        if rule.goal_type and rule.goal_type != goal.get("goal_type"):
            return False
        if rule.goal_category and rule.goal_category != goal.get("goal_category"):
            return False
        if rule.difficulty and rule.difficulty != goal.get("difficulty"):
            return False
        if hasattr(goal, "focus_area") and rule.goal_category:
            if rule.goal_category != goal.get("focus_area"):
                return False
        return True

    @staticmethod
    def compute_context_hash(context_dict: dict) -> str:
        canonical_str = json.dumps(context_dict, sort_keys=True)
        return hashlib.sha256(canonical_str.encode("utf-8")).hexdigest()

You are helping improve the performance of an AI system by tuning one of its symbolic rules.

### Current Configuration
**Target Behavior**: {{ target }}

**Current Rule Attributes:**
{% for attr, val in current_attributes.items() %}
- **{{ attr }}**: {{ val }}
{% endfor %}

**Tunable Options:**
{% for attr, options in available_options.items() %}
- **{{ attr }}**: {{ options }}
{% endfor %}

{% if recent_performance %}
### Recent Performance Insights:
{{ recent_performance }}
{% endif %}

---

### Your Task:
Propose exactly **one change** to this symbolic rule that is likely to improve the system's performance on the target behavior. This change should be grounded in your understanding of the rule's role and the available options.

### Response Format:

Rationale: <Your reasoning>

Attribute to change: \<attribute\_name>
New value: \<new\_value>

**Do not change more than one attribute. Be specific and actionable.**

Rationale: ...
Attribute to change: ...
New value: ...

Rationale: The current configuration consistently uses 'ollama_chat/mistral' without performance metrics to validate its effectiveness. Testing a different model like 'ollama_chat/qwen3' could potentially improve performance by leveraging a model with different strengths (e.g., specialized capabilities or efficiency). This change directly addresses the need to experiment with alternative models while maintaining the same rule structure.

The attribute you want to change: model.name  
The value you want to change to: ollama_chat/qwen3

pipeline_variants:
  cot:
    description: "A chain-of-thought based reasoning strategy that uses two different generators and a ranker."
    stages:
      - name: cot_generator
      - name: ranking
      - name: cot_dspy_generator

  minimal:
    description: "A basic generation pipeline with no reasoning steps. Fast and lightweight."
    stages:
      - name: generation

def list_variants_with_descriptions(self) -> list[dict]:
    return [
        {"name": name, "description": variant.get("description", "")}
        for name, variant in self.pipeline_variants.items()
    ]

## Goal:
{{ goal_text }}

## Current Pipeline:
Name: {{ current_pipeline_name }}
Description: {{ current_pipeline_description }}

## Available Pipelines:
- Name: cot A chain-of-thought based reasoning strategy...
- Name: minimal A basic generation pipeline...

## Recent Performance (optional):
{{ summary }}

### Task:
Suggest the most appropriate pipeline to achieve the goal.

### Response:
Rationale: <your reasoning>

Pipeline: <pipeline_name>

class PipelineMutationAgent(BaseAgent):
    """
    Combines symbolic rule mutation with pipeline configuration mutation.
    Generates both types of mutations, applies them, evaluates outcomes,
    and logs improvements for future learning.
    """

    def __init__(
        self,
        cfg,
        memory,
        logger,
        full_cfg=None,
    ):
        super().__init__(cfg, memory, logger)
        self.full_cfg = full_cfg
        self.target_agent = cfg.get("target_agent", "default")
        self.mutation_prompt_template = cfg["rule_mutation_prompt"]
        self.max_runs = cfg.get("max_runs", 5)


        # Load base pipeline
        self.base_pipeline_key = cfg.get("base_pipeline", "minimal")
        self.pipeline_registry_path = cfg.get("pipeline_registry", "config/registry/pipeline_registry.yaml")
        self.pipeline_registry = PipelineRegistry(self.pipeline_registry_path)

        self.rule_options_file = cfg.get("mutation_rule_options", "config/rules/pipeline_mutation_options.yaml")
        self.options_config = RuleOptionsConfig.from_yaml(self.rule_options_file)
        self.rule_tuner = RuleTuner(memory, logger)

        self.logger.log(
            "PipelineMutationAgentInitialized",
            {"conf": self.cfg}
        )

    async def run(self, context: dict) -> dict:
        # Step 1: Generate pipeline config mutations
        pipeline_def = self.pipeline_registry.get_pipeline(self.base_pipeline_key)
        if not pipeline_def:
            self.logger.log("PipelineNotFound", {"pipeline": self.base_pipeline_key})
            context["status"] = "pipeline_not_found"
            return context

        _, pipeline = self._generate_pipeline_mutations(self.base_pipeline_key, context) 


        # Step 2: Generate symbolic rule mutations
        applicable_rules = self._get_applicable_rules(pipeline)
        symbolic_mutations = []
        for rule in applicable_rules:
            symbolic_mutations.extend(self._generate_rule_mutations(rule, context))

        # Step 3: Apply and evaluate symbolic mutations
        symbolic_results = await self._apply_and_evaluate(symbolic_mutations, context)

        pipeline_to_mutate_def = self.pipeline_registry.get_pipeline(pipeline)

        # Step 4: Apply and evaluate pipeline mutations
        pipeline_results = await self._apply_pipeline_mutations(pipeline_to_mutate_def, symbolic_results, context)

        # Step 5: Log all results
        context["mutated_symbolic_rules"] = [r.to_dict() for r in symbolic_results]
        context["mutated_pipeline_runs"] = pipeline_results
        context["total_mutations_run"] = len(symbolic_results) + len(pipeline_results)

        return context

    def _get_applicable_rules(self, pipeline_name: str) -> list:
        """Get all relevant symbolic First you need to finish this for all agents in a given pipeline."""
        pipeline_def = self.pipeline_registry.get_pipeline(pipeline_name)
        agent_names = {stage.get("name") for stage in pipeline_def if "name" in stage}

        # Filter rules where the rule's agent matches any in the pipeline
        return [
            r for r in self.memory.symbolic_rules.get_all()
            if r.agent_name in agent_names
        ]

    def _generate_rule_mutations(self, rule: SymbolicRuleORM, context: dict) -> list[dict]:
        """Use LLM to generate one or more valid mutations for this rule."""
        current_attrs = rule.attributes or {}
        available_options = self.options_config.get_options_for(rule.agent_name)
        recent_perf = self.memory.rule_effects.get_recent_performance(rule.id)

        merged = {
            "current_attributes": current_attrs,
            "available_options": available_options,
            "recent_performance": recent_perf,
            **context
        }

        prompt = self.prompt_loader.from_file(self.mutation_prompt_template, self.cfg, merged)
        response = self.call_llm(prompt, context)
        parsed = RuleTuner.parse_mutation_response(response)

        if not parsed.get("attribute") or not parsed.get("new_value"):
            self.logger.log("MutationParseError", {"rule_id": rule.id, "response": response})
            return []

        attr = parsed["attribute"]
        new_val = parsed["new_value"]

        if not self.options_config.is_valid_change(rule.agent_name, attr, new_val):
            self.logger.log("InvalidRuleMutation", {"rule_id": rule.id, "attribute": attr, "value": new_val})
            return []

        if self.memory.symbolic_rules.exists_similar(rule, attr, new_val):
            self.logger.log("RuleMutationDuplicateSkipped", {"rule_id": rule.id, "attribute": attr, "value": new_val})
            return []

        mutated_attrs = dict(current_attrs)
        mutated_attrs[attr] = new_val

        new_rule = SymbolicRuleORM(
            target="agent",
            agent_name=rule.agent_name,
            goal_type=rule.goal_type,
            goal_category=rule.goal_category,
            difficulty=rule.difficulty,
            attributes=mutated_attrs,
            source="mutation",
        )
        self.memory.symbolic_rules.insert(new_rule)
        self.logger.log("RuleMutat I ionApplied", {"original_rule_id": rule.id, "new_rule": new_rule.to_dict()})
        return [new_rule]

    def _generate_pipeline_mutations(self, pipeline_name, context):
        """Generate pipeline config mutations using LLM guidance"""

        merged_context = {
            # From pipeline definition
            "current_pipeline_name": pipeline_name,
            "current_pipeline_description": self.pipeline_registry.get_description(pipeline_name),
            "current_pipeline": self.pipeline_registry.get_pipeline(pipeline_name),  # handles if it's a full pipeline block

            # From context (goal and performance)
            "goal_text": context.get("goal", {}).get("goal_text", "Improve pipeline performance"),
            "goal_id": context.get("goal", {}).get("id"),
            #TODO
            # "recent_performance": self.memory.rule_effects.get_recent_performance_summary(),

            # Optionally, inject available options for better prompting
            "available_pipelines": self.pipeline_registry.list_variants_with_descriptions(),  # e.g., [{"name": ..., "description": ...}, ...]

            # Pass original context for compatibility
            **context,
        }

        prompt = self.prompt_loader.from_file("pipeline", self.cfg, merged_context)
        response = self.call_llm(prompt, context)
        rationale, pipeline  = self._parse_pipeline_mutation(response)

        if not pipeline:
            self.logger.log("PipelineMutationParseError", {"response": response})
            return []

        return rationale, pipeline

    def _parse_pipeline_mutation(self, response: str):
        import re
        """Parse LLM response into a pipeline mutation"""
        pattern = r"""
        (?:[*#`]*\s*)?            # Optional formatting characters before the header
        rationale\s*:             # Match the word "rationale:"
        \s*(?P<rationale>.*?)     # Capture rationale content non-greedily
        (?:\n|\r|\r\n)+           # Match the newline(s) separating the two blocks
        (?:[*#`]*\s*)?            # Optional formatting characters before the second header
        pipeline\s*:\s*           # Match "pipeline:"
        (?P<pipeline>\w+)         # Capture pipeline name
        """
        match = re.search(pattern, response, re.IGNORECASE | re.DOTALL | re.VERBOSE)

        if match:
            rationale = match.group("rationale").strip()
            pipeline = match.group("pipeline").strip()
        return rationale, pipeline    
            
    async def _apply_and_evaluate(self, mutations: list[SymbolicRuleORM], context: dict) -> list[SymbolicRuleORM]:
        """Apply each symbolic mutation and evaluate its effect."""
        results = []

        for rule in mutations:
            new_config = self._apply_symbolic_rule(rule)
            mutated_context = self._update_context_with_config(context, new_config)

            supervisor = Supervisor(self.full_cfg, memory=self.memory, logger=self.logger)
            result = await supervisor.run_pipeline_config(mutated_context)

            score = self._evaluate_result(result)
            self._log_evaluation(rule, score)

            if score > 0.5:
                results.append(rule)

        return results

    def _apply_symbolic_rule(self, rule: SymbolicRuleORM):
        """Apply symbolic rule to config"""
        # You could do deeper merging here based on agent name
        return {f"{rule.agent_name}.config": rule.attributes}

    def _update_context_with_config(self, context, config_update):
        """Merge symbolic config into context"""
        ctx_copy = copy.deepcopy(context)
        ctx_copy.update(config_update)
        return ctx_copy

    async def _apply_pipeline_mutations(self, pipeline_def, mutations: list, context: dict) -> list:
        """Apply pipeline mutations and run through supervisor"""
        results = []

        for i, mutation in enumerate(mutations):
            if i >= self.max_runs:
                self.logger.log("PipelineMutationLimitReached", {"limit": self.max_runs})
                break

            mutated_pipeline = self.apply_mutation(pipeline_def, mutation)
            mutated_cfg = self.inject_pipeline_config(mutated_pipeline, tag=f"mutated_{i}")

            full_mutated_cfg = OmegaConf.merge(mutated_cfg, self.full_cfg)
            supervisor = Supervisor(full_mutated_cfg, memory=self.memory, logger=self.logger)

            try:
                mutated_run = await supervisor.run_pipeline_config(context)
                summary = self.summarize(mutated_run)
                self.logger.log("PipelineMutationRun", {"mutation": mutation, "summary": summary})
                results.append({"mutation": mutation, "result": mutated_run})
            except Exception as e:
                self.logger.log("PipelineMutationError", {"mutation": mutation, "error": str(e)})

        return results

    def apply_mutation(self, pipeline_cfg: list, mutation: dict) -> list:
        """Apply a single mutation to a deep copy of the pipeline config."""
        mutated = copy.deepcopy(pipeline_cfg)
        for key, value in mutation.items():
            keys = key.split(".")
            target = mutated
            for k in keys[:-1]:
                target = target.setdefault(k, {})
            target[keys[-1]] = value
        return mutated

    def inject_pipeline_config(self, pipeline_def, tag="mutated") -> OmegaConf:
        """Replace pipeline stages in full config"""
        full_cfg = OmegaConf.to_container(self.full_cfg, resolve=True)
        full_cfg["pipeline"]["tag"] = tag
        full_cfg["pipeline"]["stages"] = pipeline_def
        full_cfg["agents"] = {stage["name"]: stage for stage in pipeline_def}
        return OmegaConf.create(full_cfg)

    def _evaluate_result(self, result: dict) -> float:
        """Score mutation outcome using MRQScorer or other scorer"""
        score = result.get("best_score", 0.0)
        return score

    def _log_evaluation(self, rule: SymbolicRuleORM, score: float):
        """Log mutation and evaluation result"""
        self.memory.scorer.score_db.append({
            "rule_id": rule.id,
            "score": score,
            "timestamp": datetime.now(),
        })

    def summarize(self, result: dict) -> dict:
        """Return short summary for logging"""
        return {
            "goal_id": result.get("goal", {}).get("id"),
            "best_score": result.get("best_score"),
            "selected_hypothesis": result.get("selected", {}).get("text", "")[:50],
        }

    def _load_pipeline_registry(self):
        with open(self.pipeline_registry_path, "r") as f:
            return yaml.safe_load(f)