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 !
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 
