Qu’est-ce que l’évaluation par paires et comment puis-je la réaliser ?

Lorsque vous évaluez des modèles dans une évaluation Weave, les métriques à valeur absolue (par exemple, 9/10 pour le modèle A et 8/10 pour le modèle B) sont généralement plus difficiles à attribuer que les métriques relatives (par exemple, le modèle A est plus performant que le modèle B). L’évaluation par paires vous permet de comparer les sorties de deux modèles en les classant l’une par rapport à l’autre. Cette approche est utile lorsque vous souhaitez déterminer quel modèle est le plus performant pour des tâches subjectives comme la génération de texte, la synthèse ou les questions-réponses. Avec l’évaluation par paires, vous obtenez un classement relatif des préférences qui indique quel modèle est le meilleur pour des entrées précises.

Cette approche est une solution de contournement et pourra évoluer dans de futures versions. Une API plus robuste pour prendre en charge les évaluations par paires est prévue.

L’exemple de code suivant montre comment implémenter une évaluation par paires dans Weave en créant un scorer basé sur une classe nommé PreferenceScorer. PreferenceScorer compare deux modèles, ModelA et ModelB, et renvoie un score relatif des sorties des modèles, basé sur des indices explicites dans le texte d’entrée.

from weave import Model, Evaluation, Scorer, Dataset
from weave.flow.model import ApplyModelError, apply_model_async

class ModelA(Model):
    @weave.op
    def predict(self, input_text: str):
        if "Prefer model A" in input_text:
            return {"response": "This is a great answer from Model A"}
        return {"response": "Meh, whatever"}

class ModelB(Model):
    @weave.op
    def predict(self, input_text: str):
        if "Prefer model B" in input_text:
            return {"response": "This is a thoughtful answer from Model B"}
        return {"response": "I don't know"}

class PreferenceScorer(Scorer):
    @weave.op
    async def _get_other_model_output(self, example: dict) -> Any:
        """Get output from the other model for comparison.
        Args:
            example: The input example data to run through the other model
        Returns:
            The output from the other model
        """

        other_model_result = await apply_model_async(
            self.other_model,
            example,
            None,
        )

        if isinstance(other_model_result, ApplyModelError):
            return None

        return other_model_result.model_output

    @weave.op
    async def score(self, output: dict, input_text: str) -> dict:
        """Compare the output of the primary model with the other model.
        Args:
            output (dict): The output from the primary model.
            input_text (str): The input text used to generate the outputs.
        Returns:
            dict: A flat dictionary containing the comparison result and reason.
        """
        other_output = await self._get_other_model_output(
            {"input_text": input_text}
        )
        if other_output is None:
            return {"primary_is_better": False, "reason": "Other model failed"}

        if "Prefer model A" in input_text:
            primary_is_better = True
            reason = "Model A gave a great answer"
        else:
            primary_is_better = False
            reason = "Model B is preferred for this type of question"

        return {"primary_is_better": primary_is_better, "reason": reason}

dataset = Dataset(
    rows=[
        {"input_text": "Prefer model A: Question 1"},  # Model A gagne
        {"input_text": "Prefer model A: Question 2"},  # Model A gagne
        {"input_text": "Prefer model B: Question 3"},  # Model B gagne
        {"input_text": "Prefer model B: Question 4"},  # Model B gagne
    ]
)

model_a = ModelA()
model_b = ModelB()
pref_scorer = PreferenceScorer(other_model=model_b)
evaluation = Evaluation(dataset=dataset, scorers=[pref_scorer])
evaluation.evaluate(model_a)

Après avoir exécuté cette évaluation, vous disposez d’un classement de préférence relatif entre ModelA et ModelB, basé sur les résultats de PreferenceScorer.

Évaluation

Weights & Biases

Powered by CoreWeave

Platform Details

Resources

Qu’est-ce que l’évaluation par paires et comment puis-je la réaliser ?