Créer des évaluations personnalisées
Na ovoj stranici
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 à 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. 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 vous avez besoin d’évaluations personnalisées basé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 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 propriétaires du produit. Vous obtenez ainsi une définition partagée de « 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 à 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 les tests, pas seulement écrite. Les grilles évoluent : vous ajoutez un critère de conformité, en retirez un qui n’est plus utile, et la somme dérive à 1,15 sans que rien ne signale l’anomalie. Les scores restent calculables, juste faux, et comparés d’une version à l’autre, ils vous conduiront à des conclusions erronées.
Le correcteur traduit ensuite la grille en prompt, demande une note de 0 à 5 par critère, et recompose un score global pondéré. Chaque note s’accompagne d’un court commentaire : c’est ce qui vous permettra, lors de la revue des mauvais cas, 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:
"""É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 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 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 borne, votre campagne d’évaluation reste bloquée sur le premier cas échoué. Rappelez-vous aussi que vous exécutez du code que vous n’avez 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 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 série temporelle : vous voyez 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 vous 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 : 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.
Ključne točke
- 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 évaluation automatisée (code, longueur) et 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