Créer des évaluations personnalisées
In questa pagina
Leçon mise à jour le 3 novembre 2026 selon la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, alors 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.
Adapter les évaluations à ton domaine
Les correcteurs génériques ne suffisent pas à évaluer la qualité dans ton 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. Un décalage 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 tu as besoin d’évaluations personnalisées basées sur une grille explicite qui traduit tes 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 vaut 1. L’exercice le plus utile n’est pas de coder la structure, ce qui prend une quinzaine de lignes, mais de la remplir : décider que les bénéfices client pèsent 0,25 tandis que la longueur ne pèse que 0,10 force une conversation explicite avec les responsables produit. Ce que tu obtiens est une définition partagée de « bonne réponse » que personne ne pourra contester après coup.
from dataclasses import dataclass
@dataclass
class Critere:
nom: str
description: str
poids: float # 0 à 1, somme des poids = 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
# Exemple : grille pour un assistant de rédaction marketing
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 tes tests, pas seulement écrite. Les grilles évoluent : tu ajoutes un critère de conformité, tu en supprimes 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, juste faux, et comparés d’une version à l’autre, ils te 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 court commentaire : c’est ce qui te permettra, lors de la revue des mauvais cas, de comprendre si le modèle a mal répondu ou si ton critère était mal formulé.
import openai
import json
client = openai.OpenAI()
def evaluer_multi_criteres(
question: str,
reponse: str,
rubrique: Rubrique,
) -> dict:
"""Évalue une réponse selon une grille multi-critères."""
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", {})
# Calcul du score pondéré
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 tes scores semblent bloqués sous un plafond inexpliqué, inspecte 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 passe ou il ne passe pas.
import subprocess
import tempfile
def evaluer_code_python(
code_genere: str,
tests: list[str],
) -> dict:
"""Évalue du code Python en l'exécutant contre des 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, ta campagne d’évaluation reste bloquée sur le premier cas échoué. Rappelle-toi aussi que tu exécutes du code que tu n’as pas écrit : hors 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 qui copierait 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:
"""Évalue la qualité d'un résumé."""
mots_resume = len(resume.split())
ratio_longueur = min(
mots_resume / longueur_cible,
longueur_cible / max(mots_resume, 1),
)
# Fidélité 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 tu relances manuellement finit par ne plus être relancée. Le pipeline encapsule la grille et conserve un historique des campagnes, transformant une mesure ponctuelle en série temporelle : tu vois que le score moyen est passé de 0,81 à 0,79 après la modification du prompt de mardi, information qu’aucune exécution isolée n’aurait pu te donner.
class PipelineEval:
"""Pipeline d'évaluation réutilisable."""
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:
"""Évalue un lot complet et renvoie les métriques."""
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 démarrer : construis ta première grille sur seulement vingt cas, fais-la noter en parallèle par le juge LLM et par un expert du domaine, puis compare les deux séries. Les écarts te diront quels critères sont mal décrits bien avant de te dire quoi que ce soit sur la qualité du modèle.
Punti chiave
- Crée des grilles d’évaluation spécifiques à ton domaine métier, avec des pondérations explicites
- Vérifie que la somme des pondérations reste égale à 1 au fur et à mesure que la grille évolue
- Combine l’évaluation automatisée (code, longueur) et le LLM-as-Judge (qualité)
- Teste le code généré en l’exécutant, avec un délai d’attente et un environnement isolé
- Construis un pipeline réutilisable qui conserve un historique des campagnes