Créer des évaluations personnalisées
Op deze pagina
Leçon mise à jour le 3 novembre 2026 sur la base de la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, tandis que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifierreasoning={"effort": "none"}(API Responses) oureasoning_effort="none"(Chat Completions). Sources : Using GPT-6 · GPT-5.6 Terra.
Mise à jour du 2 novembre 2026 — Plateforme Evals. OpenAI a annoncé la fin de sa plateforme Evals : les évaluations existantes sont en lecture seule depuis le 31 octobre 2026, et le tableau de bord ainsi que l’API, y compris les correcteurs, fermeront le 30 novembre 2026. OpenAI a publié un guide de migration vers Promptfoo. Les principes d’évaluation de cette leçon restent valables ; seul l’outil change.
Adaptez les évaluations à votre domaine
Les correcteurs génériques ne suffisent pas à évaluer la qualité dans votre domaine spécifique. Un chatbot médical, un assistant juridique et un outil de rédaction marketing ont chacun des critères de qualité différents, et ces critères ne sont pas seulement plus nombreux : ils sont hiérarchisés différemment. Une inadéquation de ton dans une newsletter est une nuisance ; la même approximation dans une posologie est une erreur grave. Un correcteur générique traite les deux de la même manière, ce qui revient à ne rien évaluer du tout.
C’est pourquoi vous avez besoin d’évaluations personnalisées fondées sur une grille explicite qui traduit vos priorités métier en pondérations. C’est cette grille que nous allons construire.
Traduire une exigence métier en grille d’évaluation
Une grille est une liste de critères pondérés dont la somme est égale à 1. L’exercice le plus utile ne consiste pas à coder la structure, ce qui prend une quinzaine de lignes, mais à la remplir : décider que les avantages clients pèsent 0,25 tandis que la longueur ne pèse que 0,10 force une conversation explicite avec les responsables produit. Vous obtenez ainsi une définition partagée de « ce qu’est une bonne réponse » que personne ne peut contester après coup.
from dataclasses import dataclass
@dataclass
class Critere:
nom: str
description: str
poids: float # 0 to 1, sum of weights = 1
@dataclass
class Rubrique:
nom: str
criteres: list[Critere]
def valider(self) -> bool:
total = sum(c.poids for c in self.criteres)
return abs(total - 1.0) < 0.01
# Example: rubric for a marketing writing assistant
rubrique_marketing = Rubrique(
nom="Qualité rédaction marketing",
criteres=[
Critere("ton", "Le ton est professionnel et engageant", 0.20),
Critere("cta", "Contient un appel à l'action clair", 0.15),
Critere("benefices", "Met en avant les bénéfices client", 0.25),
Critere("longueur", "Respecte la longueur demandée", 0.10),
Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
Critere("marque", "Respecte les guidelines de la marque", 0.15),
],
)
La méthode valider mérite d’être appelée dans les tests, pas seulement écrite. Les grilles évoluent : vous ajoutez un critère de conformité, en supprimez un qui n’est plus utile, et la somme dérive vers 1,15 sans que rien ne signale l’anomalie. Les scores restent calculables, mais faux, et lorsqu’ils sont comparés entre versions, ils vous conduiront à des conclusions erronées.
Le correcteur traduit ensuite la grille en une invite, demande un score de 0 à 5 par critère, et recompose un score global pondéré. Chaque score s’accompagne d’un bref commentaire : c’est ce qui vous permettra, lors de l’examen des cas médiocres, de comprendre si le modèle a mal répondu ou si votre critère était mal formulé.
import openai
import json
client = openai.OpenAI()
def evaluer_multi_criteres(
question: str,
reponse: str,
rubrique: Rubrique,
) -> dict:
"""Evaluates a response against a multi-criteria rubric."""
criteres_texte = "\n".join(
f"- {c.nom} (poids: {c.poids}): {c.description}"
for c in rubrique.criteres
)
prompt = (
"Évaluez cette réponse selon les critères suivants.\n"
"Pour chaque critère, donnez un score de 0 à 5.\n\n"
f"Question posée : {question}\n"
f"Réponse à évaluer : {reponse}\n\n"
f"Critères :\n{criteres_texte}\n\n"
"Répondez en JSON avec un objet scores contenant pour chaque critère "
"un score (0-5) et un commentaire court."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0,
)
try:
resultat = json.loads(response.output_text)
scores = resultat.get("scores", {})
# Calculate weighted score
score_pondere = 0
for critere in rubrique.criteres:
if critere.nom in scores:
score_brut = scores[critere.nom]["score"] / 5.0
score_pondere += score_brut * critere.poids
return {
"score_global": score_pondere,
"scores_details": scores,
"rubrique": rubrique.nom,
}
except (json.JSONDecodeError, KeyError):
return {"score_global": 0, "erreur": "Parsing échoué"}
Attention à la boucle de calcul : un critère manquant dans la réponse du juge est silencieusement ignoré et contribue pour zéro au score pondéré. Une excellente réponse pourrait donc plafonner à 0,75 simplement parce que le juge a oublié une clé. Si vos scores semblent bloqués sous un plafond inexpliqué, inspectez scores_details avant de blâmer le modèle évalué.
Quand la machine juge mieux que l’humain
Faire évaluer du code par un LLM est un raccourci coûteux : le seul verdict qui compte est l’exécution. Le correcteur ci-dessous concatène le code généré et un test, l’écrit dans un fichier temporaire, l’exécute et compte les succès. Le score résultant ne nécessite aucune interprétation : un test réussit ou échoue, point final.
import subprocess
import tempfile
def evaluer_code_python(
code_genere: str,
tests: list[str],
) -> dict:
"""Evaluates Python code by executing it against tests."""
resultats_tests = []
for i, test in enumerate(tests):
code_complet = f"{code_genere}\n\n{test}"
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
f.write(code_complet)
f.flush()
try:
resultat = subprocess.run(
["python3", f.name],
capture_output=True,
text=True,
timeout=10,
)
succes = resultat.returncode == 0
resultats_tests.append({
"test": i,
"succes": succes,
"sortie": resultat.stdout[:200],
"erreur": resultat.stderr[:200] if not succes else "",
})
except subprocess.TimeoutExpired:
resultats_tests.append({
"test": i,
"succes": False,
"erreur": "Timeout (10s)",
})
nb_succes = sum(1 for r in resultats_tests if r["succes"])
return {
"score": nb_succes / len(tests) if tests else 0,
"tests_passes": nb_succes,
"tests_total": len(tests),
"details": resultats_tests,
}
Le timeout=10 n’est pas une précaution de confort : un modèle produit régulièrement des boucles infinies, et sans cette limite, votre campagne d’évaluation reste bloquée sur le premier cas échoué. Rappelez-vous également que vous exécutez du code que vous n’avez pas écrit : en dehors d’un environnement de développement isolé, cette fonction nécessite un bac à sable (sandbox).
Le résumé illustre un cas mixte, où une partie du jugement est mécanique et l’autre non. La longueur est mesurable : le ratio calculé pénalise symétriquement un résumé trop court et un résumé trop long, ce qui évite la ruse du modèle consistant à copier le texte source pour ne rien omettre. La fidélité, en revanche, n’est pas mesurable par une règle et revient au juge LLM, avec une question directe sur les informations inventées.
def evaluer_resume(
texte_original: str,
resume: str,
longueur_cible: int = 100,
) -> dict:
"""Evaluates summary quality."""
mots_resume = len(resume.split())
ratio_longueur = min(
mots_resume / longueur_cible,
longueur_cible / max(mots_resume, 1),
)
# Fidelity via LLM
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"Le résumé suivant est-il fidèle au texte original ? "
f"Contient-il des informations inventées ?\n\n"
f"Texte original (extrait) : {texte_original[:2000]}\n\n"
f"Résumé : {resume}\n\n"
f"Répondez en JSON avec les clés : fidélité (0-5), "
f"hallucinations (oui/non), commentaire (court)."
),
temperature=0.0,
)
try:
fidelite = json.loads(response.output_text)
except json.JSONDecodeError:
fidelite = {"fidelite": 0, "hallucinations": "inconnu"}
return {
"score_longueur": ratio_longueur,
"score_fidelite": fidelite.get("fidelite", 0) / 5.0,
"hallucinations": fidelite.get("hallucinations", "inconnu"),
"mots_resume": mots_resume,
"longueur_cible": longueur_cible,
}
Rendre l’évaluation reproductible
Une évaluation que vous relancez manuellement finit par ne plus être relancée. Le pipeline encapsule la grille et conserve un historique des campagnes, transformant une mesure ponctuelle en une série temporelle : vous voyez que le score moyen est passé de 0,81 à 0,79 après la modification de l’invite de mardi, information qu’aucune exécution isolée n’aurait pu vous donner.
class PipelineEval:
"""Reusable evaluation pipeline."""
def __init__(self, nom: str, rubrique: Rubrique):
self.nom = nom
self.rubrique = rubrique
self.historique: list[dict] = []
def evaluer_batch(
self,
dataset: list[dict],
modele: str,
prompt_systeme: str,
) -> dict:
"""Evaluates a full batch and returns metrics."""
resultats = []
for cas in dataset:
response = client.responses.create(
model=modele,
instructions=prompt_systeme,
input=cas["input"],
)
eval_result = evaluer_multi_criteres(
cas["input"],
response.output_text,
self.rubrique,
)
resultats.append(eval_result)
scores = [r["score_global"] for r in resultats]
rapport = {
"pipeline": self.nom,
"modele": modele,
"nb_cas": len(dataset),
"score_moyen": sum(scores) / len(scores),
"score_min": min(scores),
"score_max": max(scores),
}
self.historique.append(rapport)
return rapport
Un conseil pour commencer : construisez votre première grille sur seulement vingt cas, faites-la noter en parallèle par le juge LLM et par un expert du domaine, puis comparez les deux séries. Les écarts vous indiqueront quels critères sont mal décrits bien avant de vous dire quoi que ce soit sur la qualité du modèle.
Belangrijkste punten
- Créez des grilles d’évaluation spécifiques à votre domaine métier, avec des pondérations explicites
- Vérifiez que la somme des pondérations reste égale à 1 au fur et à mesure que la grille évolue
- Combinez l’évaluation automatisée (code, longueur) et le LLM-as-Judge (qualité)
- Testez le code généré en l’exécutant, avec un délai d’attente et un environnement isolé
- Construisez un pipeline réutilisable qui conserve un historique des campagnes