« Ça a l'air de marcher » n'est pas une évaluation. Pour comparer, choisir et surveiller un système d'IA, il faut des cas, des métriques, de la variance et de l'honnêteté.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : avancé · 🏅 Badge : Mesureur de systèmes d'IA
🎬 L'histoire
Deux prompts pour la classification des tickets de HashBox. Kodi les essaie sur cinq exemples : le premier se trompe une fois, le second aucune. Il déploie le second. En production, le second se trompe plus souvent que le premier. Sam examine : les cinq exemples étaient tirés de la documentation du prompt gagnant (il les avait déjà « vus »), l'échantillon était minuscule, et les deux prompts avaient été lancés une seule fois chacun, avec une température non nulle.
« Cinq exemples, une exécution, des cas qui ressemblent à la réponse : ce n'est pas une mesure, c'est une impression, dit Sam. Évaluer un système d'IA, c'est construire un instrument : un jeu de cas représentatif, des critères objectifs, plusieurs exécutions, un intervalle de confiance, une comparaison appariée — et se méfier des fuites entre entraînement et test. »
Tu apprends à construire un jeu d'évaluation, à choisir des métriques (exactitude, précision/rappel, pass@k), à estimer l'incertitude, à comparer deux systèmes de façon appariée, à mesurer l'accord entre annotateurs (kappa), à détecter la contamination, et à éviter les pièges (Goodhart, juges automatiques complaisants).
🎯 Ta mission
À la fin, je serai capable de :
- construire un jeu d'évaluation représentatif avec des critères de correction objectifs
- calculer exactitude, précision, rappel, F1 et pass@k (estimateur non biaisé)
- estimer l'incertitude par bootstrap et comparer deux systèmes sur les mêmes cas
- mesurer l'accord entre annotateurs avec le kappa de Cohen
- détecter la contamination et repérer les pièges d'évaluation (Goodhart, juge automatique)
🧩 Défi d'échauffement (5 XP)
Un professeur veut savoir si deux méthodes d'enseignement diffèrent. Il teste la première sur 5 élèves, la seconde sur 5 autres élèves, après avoir donné à la seconde classe les corrigés de l'examen. Cite les erreurs de méthode. Comment procéderais-tu pour que la comparaison soit honnête ?
💡 Le concept
Que veut-on évaluer ?
Avant les métriques : la tâche, qui utilisera le système, ce qu'est une erreur grave. Une évaluation sert à décider (déployer ? changer de modèle ? corriger le prompt ?) ou à surveiller (régression).
Le jeu d'évaluation
| Qualité | Exigence |
|---|---|
| Représentatif | reflète les vraies entrées (types, difficulté, fréquence) |
| Divers | cas faciles, difficiles, limites, cas piégeux, hors périmètre |
| Étiqueté de façon fiable | critère de correction écrit, accord entre annotateurs mesuré |
| Séparé | jamais utilisé pour concevoir le prompt ou entraîner (sinon : surajustement) |
| Assez grand | l'incertitude doit être acceptable (au moins quelques dizaines à centaines de cas) |
| Versionné | pour comparer dans le temps |
Découper : un jeu de développement (on itère dessus) et un jeu de test (on ne le regarde qu'à la fin).
Métriques selon la tâche
| Tâche | Métriques |
|---|---|
| Classification | exactitude, précision, rappel, F1, matrice de confusion |
| Code | taux de réussite des tests (pass@k) |
| Extraction | correspondance exacte, F1 sur les champs |
| Génération libre | critères vérifiables (grille), comparaison par paires, juge humain ou automatique calibré |
| RAG | rappel@k, fidélité aux sources, taux de refus justifié (mission 4) |
| Agents | taux de tâches résolues, coût, violations (mission 6) |
Précision, rappel, F1
précision = VP / (VP + FP) rappel = VP / (VP + FN) F1 = 2·P·R / (P + R)
Selon le coût des erreurs : détecter une fuite de données (rappel d'abord) ou envoyer un avertissement à tort (précision d'abord).
pass@k
Pour du code : on génère n solutions, c passent les tests. La probabilité qu'au moins une de k solutions tirées passe vaut (estimateur non biaisé) :
pass@k = 1 − C(n − c, k) / C(n, k)
Variance et incertitude
- Un système échantillonné varie d'une exécution à l'autre : lancer plusieurs fois, rapporter moyenne et dispersion.
- Toute métrique sur
ncas a une incertitude : intervalle de confiance par bootstrap (rééchantillonner les cas) ou de Wilson (proportion). - « 82 % contre 79 % » sur 50 cas ne prouve rien.
Comparer deux systèmes
- Mêmes cas pour les deux (comparaison appariée) : on regarde, cas par cas, qui gagne.
- Test sur les discordances (cas où l'un réussit et pas l'autre) : test de McNemar, ou bootstrap de la différence.
- Rapporter la différence avec son intervalle, pas deux nombres isolés.
Accord entre annotateurs : kappa de Cohen
κ = (accord observé − accord attendu par hasard) / (1 − accord attendu par hasard)
κ > 0,8 : excellent ; 0,6-0,8 : bon ; < 0,4 : faible — les critères sont flous, et aucun système ne peut être jugé de façon fiable.
La contamination
Si des cas du jeu de test figurent dans les données d'entraînement (ou dans tes prompts d'exemples), le score est gonflé. Détection : recouvrement de n-grammes entre test et corpus connu ; cas « canari » ; jeux de test privés ; renouvellement.
Les pièges
| Piège | Remède |
|---|---|
| Goodhart (métrique optimisée → plus fiable) | plusieurs métriques, jeu de test caché, revue qualitative |
| Juge automatique (un modèle note un autre) | calibrer sur des notes humaines, mesurer l'accord, biais de longueur / de position |
| Moyenne qui cache les cas graves | analyser par catégorie et par gravité |
| Évaluer sur un seul exemple ou une seule exécution | échantillon, répétitions |
| Benchmarks publics | utiles pour comparer des modèles, pas pour valider ton usage |
| Coût ignoré | rapporter latence, coût par tâche réussie |
Évaluation continue
Les modèles, les prompts, les données changent : jouer le banc à chaque changement (régression) et surveiller en production (échantillonnage + relecture humaine, signaux de dérive).
🧠 Astuce : avant de lancer une évaluation, écris la décision qu'elle va éclairer et le seuil qui la déclenche. Sinon, tu choisiras le seuil après avoir vu les chiffres.
🔍 Exemple pas à pas
Problème : calculer précision, rappel, F1 et pass@k ; estimer l'incertitude par bootstrap ; comparer deux systèmes de façon appariée ; mesurer l'accord entre annotateurs ; détecter la contamination ; et montrer qu'une évaluation sur cinq exemples est trompeuse.
import math, random
from itertools import combinations
# ---------------- 1. précision, rappel, F1 ----------------
def prf(vrais, predits, positif):
vp = sum(1 for v, p in zip(vrais, predits) if v == positif and p == positif)
fp = sum(1 for v, p in zip(vrais, predits) if v != positif and p == positif)
fn = sum(1 for v, p in zip(vrais, predits) if v == positif and p != positif)
precision = vp / (vp + fp) if vp + fp else 0.0; rappel = vp / (vp + fn) if vp + fn else 0.0
return precision, rappel, (2 * precision * rappel / (precision + rappel) if precision + rappel else 0.0)
V = ["fuite"] * 10 + ["ok"] * 90
P_prudent = ["fuite"] * 6 + ["ok"] * 4 + ["ok"] * 90
P_alarmiste = [] * + [] * + [] *
nom, p ((, P_prudent), (, P_alarmiste)):
pr, ra, f1 = prf(V, p, ); exact = (v == x v, x (V, p)) / (V)
()
prf(V, P_prudent, )[] == prf(V, P_alarmiste, )[] ==
()
():
n - c < k:
- math.comb(n - c, k) / math.comb(n, k)
(, {k: (pass_at_k(, , k), ) k (, , , )})
(pass_at_k(, , ), ) == pass_at_k(, , ) >
():
rng = random.Random(graine); n = (resultats)
moyennes = ((rng.choice(resultats) _ (n)) / n _ (b)); moyennes[( * b)], moyennes[( * b)]
rng = random.Random()
vrai_taux_A, vrai_taux_B = ,
cas_A = [ rng.random() < vrai_taux_A _ ()]
petit = [, , , , ]
()
ic_bootstrap(cas_A)[] - ic_bootstrap(cas_A)[] < ic_bootstrap(petit)[] - ic_bootstrap(petit)[] >=
():
r = random.Random(graine); difficulte = [r.random() _ (n)]
A = [ r.random() < - * d d difficulte]
B = [ r.random() < - * d d difficulte]
A, B
A, B = simuler_paire(, )
():
rng = random.Random(graine); n = (A); idx = (n)
d = ((B[i] - A[i] i (rng.choice(idx) _ (n))) / n _ (b)); d[( * b)], d[( * b)]
bas, haut = diff_bootstrap(A, B)
b01 = ( a, b (A, B) a == b == ); b10 = ( a, b (A, B) a == b == )
chi2 = ((b01 - b10) - ) ** / (b01 + b10) b01 + b10
()
(bas > ) == (chi2 > )
():
n = (a); po = (x == y x, y (a, b)) / n
cats = (a) | (b); pe = ((a.count(c) / n) * (b.count(c) / n) c cats)
(po - pe) / ( - pe)
r = random.Random(); verite = [r.choice([, , ]) _ ()]
(): [v r.random() < taux r.choice([, , ]) v verite]
nom, taux ((, ), (, )):
()
kappa(annotateur(), annotateur()) > > kappa(annotateur(), annotateur())
():
mots = texte.lower().split(); {(mots[i:i + n]) i ((mots) - n + )}
CORPUS_CONNU =
TEST = [, , ]
connus = ngrammes(CORPUS_CONNU)
t TEST:
g = ngrammes(t); rec = (g & connus) / ((g), ); ()
(ngrammes(TEST[]) & connus) / (ngrammes(TEST[])) == (ngrammes(TEST[]) & connus) ==
():
r = random.Random(graine); a = (r.random() < _ (n)); b = (r.random() < _ (n)); b > a
n (, , , ):
bonne = (decision_sur_n(n, g) g ()) /
()
(decision_sur_n(, g) g ()) / < (decision_sur_n(, g) g ()) /
Lecture :
- L'exactitude peut tromper : un système « prudent » à 96 % laisse passer 40 % des fuites ; le système « alarmiste » à 80 % les trouve toutes. Le bon choix dépend du coût des erreurs, que précision et rappel rendent visible.
- pass@k mesure la chance d'obtenir au moins une solution correcte parmi
kessais ; avec 4 bonnes solutions sur 20,pass@1 = 20 %maispass@10 > 95 %: très utile si un vérificateur automatique peut sélectionner la bonne (mission 8). - Sur 5 cas, l'incertitude est énorme ; sur 200 elle reste de plusieurs points.
- La comparaison appariée s'appuie sur les discordances et sur l'intervalle de la différence. Ici, B fait +4 points sur 300 cas, mais l'intervalle contient 0 et le test de McNemar n'est pas significatif : on ne peut pas conclure — mieux vaut le savoir que décider au hasard.
- Le kappa montre que des critères flous (κ faible) rendent toute évaluation peu fiable.
- Le recouvrement de n-grammes repère un cas de test déjà présent dans un corpus connu : le score serait gonflé.
- Avec 5 cas, le meilleur système ne « gagne » que dans 41 % des évaluations (les égalités comptent comme non-victoire) ; il faut des centaines de cas pour détecter une différence de 4 points : 80 % des évaluations à 200 cas, 99 % à 1 000.
✍️ À toi, avec aide (10 XP)
Un classificateur de tickets a produit ces résultats sur 200 tickets (classe « urgent » = positive) :
| Prédit urgent | Prédit non urgent | |
|---|---|---|
| Vraiment urgent | 38 | 12 |
| Vraiment non urgent | 22 | 128 |
- Calcule exactitude, précision, rappel, F1.
- Un ticket urgent non détecté coûte en moyenne 400 € ; une fausse alerte coûte 20 €. Quel est le coût total sur ces 200 tickets ? Quel serait le coût si l'on détectait 10 urgents de plus au prix de 30 fausses alertes de plus ?
- Que préfères-tu optimiser, précision ou rappel ? Justifie avec les coûts.
- Calcule un intervalle de Wilson sur le rappel (38/50).
💡 Indice 1
Précision = VP / (VP + FP) ; rappel = VP / (VP + FN).
💡 Indice 2
Coût = FN × 400 + FP × 20.
💡 Indice 3
Wilson : voir mission HEF-150.
✅ Réponse
import math
vp, fn, fp, vn = 38, 12, 22, 128
precision, rappel = vp / (vp + fp), vp / (vp + fn)
f1 = 2 * precision * rappel / (precision + rappel)
print(f"exactitude {(vp + vn) / 200:.1%} | précision {precision:.1%} | rappel {rappel:.1%} | F1 {f1:.2f}")
cout = lambda fn, fp: fn * 400 + fp * 20
print("coût actuel :", cout(fn, fp), "€ ; après +10 détections et +30 fausses alertes :", cout(fn - 10, fp + 30), "€")
def wilson(s, n, z=1.96):
p = s / n; c = (p + z * z / (2 * n)) / (1 + z * z / n); d = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n); return c - d, c + d
print("IC95 du rappel : [%.0f%% ; %.0f%%]" % tuple(100 * x for x in wilson(38, 50)))
assert cout(12, ) == cout(, ) ==
🚀 À toi, en solo (20 XP)
Banc d'évaluation de bout en bout. Construis un petit cadre d'évaluation réutilisable :
- un jeu de 60 cas de classification de tickets en 4 catégories (avec 8 cas piégeux et 6 hors périmètre) généré avec graine fixée, et deux « systèmes » simulés (taux d'erreur différents par catégorie) ;
- séparation développement / test ; le banc refuse de calculer un score sur le jeu de test plus d'une fois par système (compteur d'accès) pour décourager le surajustement ;
- métriques par catégorie (précision, rappel, F1), matrice de confusion, exactitude globale avec IC ;
- exécutions multiples (20 graines) pour un système échantillonné : moyenne et dispersion ;
- comparaison appariée avec IC de la différence et test de McNemar ;
- détection de contamination entre exemples du prompt (few-shot) et jeu de test (recouvrement) ;
- règle de décision écrite d'avance (« déployer B si l'IC bas de la différence > 0 ET le rappel de la catégorie critique ≥ 90 % »), puis application ;
- rapport texte reproductible.
✅ Pistes de correction
import random, math
from collections import Counter
CATS = ["paiement", "compte", "technique", "autre"]
def jeu(graine=1, n=60):
r = random.Random(graine); cas = []
for i in range(n):
v = r.choice(CATS); cas.append(dict(id=i, texte=f"ticket {i} sur {v}", verite=v, piege=i < 8, hors=i >= n - 6))
for c in cas:
if c["hors"]: c["verite"] = "autre"
return cas
class Banc:
def __init__(self, cas, part_dev=0.5, graine=0):
r = random.Random(graine); idx = list(range(len(cas))); r.shuffle(idx); k = int(len(cas) * part_dev)
self.dev, self.test = [cas[i] for i in idx[:k]], [cas[i] for i idx[k:]]; .acces_test = Counter()
():
.acces_test[nom_systeme] +=
.acces_test[nom_systeme] > : PermissionError()
[systeme(c) c .test]
():
r = random.Random(graine)
():
e = taux_critique c[] == taux_base
c[]: e *=
r.choice([x x CATS x != c[]]) r.random() < e c[]
f
cas = jeu(); banc = Banc(cas)
sA, sB = systeme(, , ), systeme(, , )
pA, pB = banc.scorer_test(, sA), banc.scorer_test(, sB)
verites = [c[] c banc.test]
():
vp = (v == cat == p v, p (verites, pred)); fp = (v != cat p == cat v, p (verites, pred)); fn = (v == cat p != cat v, p (verites, pred))
(vp / (vp + fp) vp + fp ), (vp / (vp + fn) vp + fn )
nom, p ((, pA), (, pB)):
(nom, , , , ((x, ) x prf(, p)))
: banc.scorer_test(, sB); AssertionError
PermissionError e: (, e)
A_ok = [(v == x) v, x (verites, pA)]; B_ok = [(v == x) v, x (verites, pB)]
rng = random.Random(); n = (A_ok)
d = ((B_ok[i] - A_ok[i] i (rng.randrange(n) _ (n))) / n _ ())
bas, haut = d[], d[]
rappel_critique = prf(, pB)[]
decision = bas > rappel_critique >=
()
FEW_SHOT = [, ]
contamines = [c[] c banc.test (c[] == e e FEW_SHOT)]
(, contamines )
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Évaluer sur quelques exemples | Incertitude énorme, décisions au hasard | Centaines de cas, intervalles de confiance |
| Itérer sur le jeu de test | Surajustement : le score ne vaut plus rien | Séparer développement / test ; jeu caché |
| Une seule exécution d'un système échantillonné | Variance ignorée | Plusieurs exécutions, moyenne et dispersion |
| Faire confiance à un juge automatique sans le calibrer | Biais de longueur, complaisance | Comparer à des notes humaines, mesurer l'accord |
🐉 Mini-boss (40 XP)
Rapport d'évaluation d'un assistant de HashBox. Évalue un assistant (simulé) qui répond à des questions de support avec RAG :
- jeu de 100 cas (dont 15 hors corpus, 10 pièges, 10 sur documents contradictoires) avec critères de correction écrits ; deux annotateurs simulés ; kappa ;
- séparation développement / test ; protocole d'accès unique au test ;
- métriques : exactitude factuelle, fidélité aux sources, taux de refus justifié, taux de réponse à tort, rappel@k de la récupération ;
- 20 exécutions par système ; intervalles ; comparaison appariée de deux versions du prompt et de deux tailles de morceaux ;
- détection de contamination ;
- analyse par catégorie et par gravité : lister les 5 erreurs les plus graves ;
- coût et latence par réponse correcte ;
- décision écrite d'avance et application ; recommandations ; ce que l'évaluation ne dit pas.
✅ Pistes de correction
Un bon rapport : critères de correction écrits et kappa > 0,7, protocole d'accès unique au test, tableau de métriques avec intervalles, comparaison appariée avec McNemar et IC de la différence, analyse des erreurs graves (réponse à tort sur des questions hors corpus), coût par réponse correcte, décision conforme à la règle écrite et section « limites » honnête (jeu simulé, taille limitée, juge non indépendant).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pour comparer deux systèmes, on évalue de préférence :
- A. les deux sur les mêmes cas, en regardant la différence et son intervalle
- B. chacun sur des cas différents
- C. un seul exemple chacun
2. Le kappa de Cohen mesure :
- A. la vitesse du modèle
- B. l'accord entre annotateurs au-delà du hasard
- C. la taille du jeu de test
3. La contamination d'un benchmark signifie que :
- A. le jeu de test est trop grand
- B. le modèle est trop lent
- C. des cas de test figurent dans les données d'entraînement ou les exemples, gonflant le score
4. 🔁 Révision mission 06 : Pour empêcher un agent de « réussir » en modifiant les tests, on :
- A. met les fichiers de mesure en lecture seule et vérifie de façon indépendante
- B. lui demande poliment de ne pas le faire
- C. augmente la température
5. 🔁 Révision mission 06 : Si chaque étape réussit à 90 %, la réussite globale sur 10 étapes est environ :
- A. 90 %
- B. 35 %
- C. 99 %
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quelle décision d'IA a été prise dans ton équipe sur la base de très peu d'exemples ?
- Quel cas grave ton jeu d'évaluation actuel ne contient-il pas ?
🎒 À retenir
- Jeu représentatif, séparé, versionné ; critères objectifs ; kappa.
- Précision, rappel, F1 selon le coût des erreurs ; pass@k pour le code.
- Bootstrap, Wilson : toute métrique a une incertitude.
- Comparaison appariée sur les mêmes cas ; McNemar.
- Contamination, Goodhart, juges automatiques : méfiance et jeu de test caché.
flowchart LR
T(["Évaluation et benchmarks"])
T --> R1["1. Jeu représentatif, séparé, versionné ; critères objectifs ; kappa."]
T --> R2["2. Précision, rappel, F1 selon le coût des erreurs ; pass@k pour le code."]
T --> R3["3. Bootstrap, Wilson : toute métrique a une incertitude."]
T --> R4["4. Comparaison appariée sur les mêmes cas ; McNemar."]
T --> R5["5. Contamination, Goodhart, juges automatiques : méfiance et jeu de test…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Mesureur de systèmes d'IA
← Mission 06 — Agents et boucles d'exécution · Mission 08 — Vérification humaine et tests →
HEF-160 — IA et augmentation humaine

