Qu’est-ce que l’évaluation par paires et comment puis-je la mettre en œuvre ?

Lorsque vous évaluez des modèles dans le cadre d’une évaluation Weave, les métriques à valeur absolue (par ex. 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 ex. 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 particulièrement utile lorsque vous souhaitez déterminer quel modèle est le plus performant pour des tâches subjectives telles que la génération de texte, le résumé ou les questions-réponses. Avec l’évaluation par paires, vous pouvez obtenir un classement de préférence relatif qui indique quel modèle est le meilleur pour des entrées spécifiques.

Cette approche est une solution de contournement et pourra évoluer dans de futures versions. Nous travaillons activement sur une API plus robuste pour prendre en charge les évaluations par paires. Restez à l’écoute des prochaines mises à jour !

L’exemple de code suivant montre comment implémenter une évaluation par paires dans Weave en créant un scorer défini sous forme de classe appelé PreferenceScorer. Le PreferenceScorer compare deux modèles, ModelA et ModelB, et renvoie un score relatif des sorties des modèles en fonction d’indices explicites présents 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:
        """Obtenir la sortie de l'autre modèle pour comparaison.
        Args:
            example: Les données d'exemple d'entrée à faire passer par l'autre modèle
        Returns:
            La sortie de l'autre modèle
        """

        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:
        """Comparer la sortie du modèle principal avec l'autre modèle.
        Args:
            output (dict): La sortie du modèle principal.
            input_text (str): Le texte d'entrée utilisé pour générer les sorties.
        Returns:
            dict: Un dictionnaire plat contenant le résultat de la comparaison et la raison.
        """
        other_output = await self._get_other_model_output(
            {"input_text": input_text}
        )
        if other_output is None:
            return {"primary_is_better": False, "reason": "L'autre modèle a échoué"}

        if "Prefer model A" in input_text:
            primary_is_better = True
            reason = "Le modèle A a fourni une excellente réponse"
        else:
            primary_is_better = False
            reason = "Le modèle B est préféré pour ce type de question"

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

dataset = Dataset(
    rows=[
        {"input_text": "Prefer model A: Question 1"},  # Le modèle A gagne
        {"input_text": "Prefer model A: Question 2"},  # Le modèle A gagne
        {"input_text": "Prefer model B: Question 3"},  # Le modèle B gagne
        {"input_text": "Prefer model B: Question 4"},  # Le modèle 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)

Évaluation

Weights & Biases

Powered by CoreWeave

Platform Details

Resources

Qu’est-ce que l’évaluation par paires et comment puis-je la mettre en œuvre ?