Lors de la construction de flux de travail d'évaluation de requêtes, les évaluateurs fournissent des signaux objectifs sur la qualité des résultats. Un évaluateur prend la sortie du modèle et renvoie une forme de retour mesurable - généralement un nombre entre 1 et 10, où 10 représente une qualité élevée et 1 une mauvaise qualité.
Types d'évaluateurs

Il existe trois approches principales pour évaluer les sorties des modèles :
- Évaluateurs par code - Évaluent les sorties de manière programmatique à l'aide d'une logique personnalisée
- Évaluateurs par modèle - Utilisent un autre modèle d'IA pour évaluer la qualité
- Évaluateurs humains - Font appel à des personnes pour examiner et noter manuellement les sorties
Évaluateurs par code
Les évaluateurs par code vous permettent de mettre en œuvre n'importe quelle vérification programmatique imaginable. Les usages courants incluent :
- Vérification de la longueur de la sortie
- Vérification de la présence ou de l'absence de certains mots dans la sortie
- Validation syntaxique pour JSON, Python ou les expressions régulières
- Scores de lisibilité
La seule exigence est que votre code renvoie un signal mesurable à son exécution.
Évaluateurs par modèle
Les évaluateurs par modèle effectuent une requête API supplémentaire pour évaluer la sortie d'origine. Cette approche offre une flexibilité considérable pour évaluer :
- La qualité de la réponse
- La qualité du respect des instructions
- L'exhaustivité
- L'utilité
- La sécurité
Évaluateurs humains
Les évaluateurs humains offrent la plus grande flexibilité mais sont chronophages et fastidieux. Ils sont utiles pour évaluer :
- La qualité générale de la réponse
- L'exhaustivité
- La profondeur
- La concision
- La pertinence
Définir des critères d'évaluation

Avant de mettre en œuvre un évaluateur, vous avez besoin de critères d'évaluation clairs. Pour une requête de génération de code, vous pourriez vous concentrer sur :
- Format - Doit renvoyer uniquement du Python, du JSON ou une expression régulière, sans explication
- Syntaxe valide - Le code produit doit avoir une syntaxe valide
- Respect de la tâche - La réponse doit répondre directement à la tâche de l'utilisateur avec un code exact

Les deux premiers critères fonctionnent bien avec les évaluateurs par code, tandis que le respect de la tâche est mieux adapté aux évaluateurs par modèle en raison de leur flexibilité.
Mettre en œuvre un évaluateur par modèle
Voici comment construire une fonction d'évaluateur par modèle :
def grade_by_model(test_case, output):
# Créer une requête d'évaluation
eval_prompt = f"""
You are an expert code reviewer. Evaluate this AI-generated solution.
Task: {test_case["task"]}
Solution: {output}
Provide your evaluation as a structured JSON object with:
- "strengths": An array of 1-3 key strengths
- "weaknesses": An array of 1-3 key areas for improvement
- "reasoning": A concise explanation of your assessment
- "score": A number between 1-10
"""
messages = []
add_user_message(messages, eval_prompt)
add_assistant_message(messages, "```json")
eval_text = chat(messages, stop_sequences=["```"])
return json.loads(eval_text)L'idée clé est de demander les points forts, les points faibles et le raisonnement en plus du score. Sans ce contexte, les modèles ont tendance à se rabattre par défaut sur des scores moyens autour de 6.
Intégrer l'évaluateur
Mettez à jour votre fonction de cas de test pour utiliser l'évaluateur par modèle :
def run_test_case(test_case):
output = run_prompt(test_case)
# Obtenir l'évaluation du modèle
model_grade = grade_by_model(test_case, output)
score = model_grade["score"]
reasoning = model_grade["reasoning"]
return {
"output": output,
"test_case": test_case,
"score": score,
"reasoning": reasoning
}Calculer les scores moyens
Pour obtenir un indicateur de performance global, calculez le score moyen sur l'ensemble des cas de test :
from statistics import mean
def run_eval(dataset):
results = []
for test_case in dataset:
result = run_test_case(test_case)
results.append(result)
average_score = mean([result["score"] for result in results])
print(f"Average score: {average_score}")
return resultsCela vous donne un indicateur concret et objectif pour suivre la performance de votre requête au fil du temps. Bien que les évaluateurs par modèle puissent être quelque peu incohérents, ils constituent un point de départ pour mesurer et améliorer vos requêtes de manière systématique.