> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

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

Lorsque vous [évaluez](/fr/weave/guides/evaluation/scorers) des modèles dans une [évaluation](/fr/weave/guides/core-types/evaluations) 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.

<Warning>
  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.
</Warning>

L’exemple de code suivant montre comment implémenter une évaluation par paires dans Weave en créant un [scorer basé sur une classe](/fr/weave/guides/evaluation/scorers#class-based-scorers) 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.

```python lines theme={null}
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`.

***

<Badge stroke shape="pill" color="orange" size="md">[Évaluation](/fr/support/weave/tags/evaluation)</Badge>