Module L32 · Partie K · Ingénierie de l’IA

Métriques : tout ce qu’il faut pour critiquer un modèle, un RAG, un prompt, un agent.

Un système d’IA ne vaut que ce que sa mesure permet d’affirmer. Ce chapitre — le plus long de la partie — donne toutes les métriques qu’un ingénieur ou un chercheur doit savoir calculer, interpréter et contester : classification, régression, classement et recherche, génération de texte, LLM et benchmarks, RAG, prompts, agents, OCR/ASR/vision, calibration et incertitude, robustesse, équité, efficacité et coût, évaluation humaine et par LLM-juge — et la statistique qui rend une comparaison valide. Chaque métrique est implémentée, avec ses théorèmes, ses pièges et les articles.

Durée : 6 séances · Prérequis : L11, L13, L24, L26–L31. Objectifs : calculer et interpréter ≈ 40 métriques ; démontrer les propriétés clés (AUC = probabilité de bon ordre, décomposition du Brier, estimateur pass@k) ; construire un protocole d’évaluation complet avec intervalles de confiance et tests ; détecter les fuites, la contamination et le Goodhart ; lire un classement public avec scepticisme.

Ce que vous saurez faire à la fin

Choisir la métrique qui correspond au coût métier et la justifier.
Produire un rapport d’évaluation : métriques, IC bootstrap, tests appariés, analyse d’erreurs par segment.
Évaluer un RAG et un agent bout en bout, composant par composant.
Calibrer et valider un LLM-juge contre des humains (kappa, accord, biais).

Plan

Carte du chapitre

Partie	Contenu	Métriques
01 Classification	Matrice de confusion, seuils, courbes	Exactitude, précision, rappel, F_β, micro/macro, MCC, log-loss, ROC-AUC, PR-AUC/AP, top-k
02 Calibration et incertitude	Probabilités fiables	Brier et sa décomposition, ECE, diagramme de fiabilité, NLL, intervalles de prédiction, couverture conforme
03 Régression et séries	Erreurs et échelles	MAE, RMSE, MAPE, sMAPE, R², quantiles/pinball, MASE
04 Classement et recherche	RAG, recommandation	P@k, R@k, MRR, MAP, nDCG, hit rate ; précision/rappel de contexte
05 Génération de texte	Traduction, résumé, LLM	Perplexité, BLEU, chrF, ROUGE, METEOR, BERTScore, exact match, F1 token, pass@k
06 LLM et benchmarks	Classements et pièges	MMLU, GSM8K, HumanEval, MT-Bench, Arena/Elo, contamination, variance de prompt
07 RAG, prompts, agents	Systèmes composés	Fidélité, pertinence, citations, refus ; taux de réussite de tâche, pas, coût, sécurité
08 Perception	OCR, ASR, vision	CER/WER, IoU, mAP, DER, PSNR/SSIM/FID
09 Robustesse et équité	Hors distribution, biais	Écart OOD, robustesse adverse, parité démographique, égalité des chances, calibration par groupe
10 Efficacité et coût	Production	Latence p50/p95, débit, coût par requête, énergie, empreinte mémoire
11 Évaluation humaine et LLM-juge	Jugements	Kappa, alpha de Krippendorff, Bradley-Terry/Elo, biais du juge
12 Statistique	Conclure	Bootstrap, tests appariés, McNemar, corrections multiples, taille d’effet, puissance

Fiche de cours · Définitions

Définitions transversales

Définition (métrique, fonction de perte, objectif métier). La perte est ce que l’optimiseur minimise (différentiable) ; la métrique est ce qu’on rapporte (souvent non différentiable : exactitude, F1) ; l’objectif métier est ce qui compte vraiment (coût des erreurs, revenu, sécurité). Les trois diffèrent ; l’évaluation consiste à relier la métrique à l’objectif métier.

Définition (jeu de test, fuite, contamination). Jeu de test : données jamais vues pendant l’entraînement ni la sélection de modèle. Fuite : information du test qui atteint l’entraînement (doublons, prétraitement global, sélection sur le test). Contamination : données de benchmark présentes dans le corpus de pré-entraînement d’un LLM.

Définition (métrique propre — proper scoring rule). Une règle de score S(p, y) est propre si l’espérance E_y∼q[S(p, y)] est maximale (ou minimale pour une perte) en p = q : elle incite à annoncer ses vraies probabilités. Log-loss et Brier sont propres ; l’exactitude ne l’est pas (elle ignore la confiance).

Définition (Goodhart). « Quand une mesure devient un objectif, elle cesse d’être une bonne mesure » : optimiser une métrique proxy (longueur de réponse, BLEU, score d’un juge) produit des solutions qui la satisfont sans satisfaire l’objectif (reward hacking, L27).

Définition (segment, tranche). Sous-population du jeu de test (par condition, groupe, difficulté). Une métrique globale cache les tranches ; l’évaluation par tranche révèle où le système échoue.

Définition (évaluation intrinsèque, extrinsèque). Intrinsèque : la sortie contre une référence (BLEU, WER). Extrinsèque : l’effet sur la tâche aval (temps de post-édition d’une traduction, taux de commandes exécutées). L’extrinsèque est la vérité, l’intrinsèque un proxy.

Fiche de cours · Formules

Formulaire général (1/2) : classification, calibration, régression

Matrice de confusion (binaire) : VP, FP, FN, VN ; exactitude = (VP+VN)/n ; précision P = VP/(VP+FP) ; rappel R = VP/(VP+FN) ; spécificité = VN/(VN+FP) ; F_β = (1+β²)PR/(β²P + R) ; F1 = 2PR/(P+R)

MCC = (VP·VN − FP·FN)/√((VP+FP)(VP+FN)(VN+FP)(VN+FN)) ∈ [−1, 1] — équilibré même sous déséquilibre de classes

Multi-classes : macro-F1 = moyenne des F1 par classe (chaque classe compte autant) ; micro-F1 = F1 sur les comptes agrégés (= exactitude en mono-étiquette) ; pondérée = par support

Log-loss = −(1/n)Σ log p(y_i) ; Brier = (1/n)Σ (p_i − y_i)² ; ECE = Σ_bins (n_b/n)·|exactitude_b − confiance_b|

ROC : TPR(t) = R(t) vs FPR(t) = FP/(FP+VN) quand le seuil t varie ; AUC = P(score(positif) > score(négatif)) ; PR-AUC / AP = Σ_k (R_k − R_k−1)P_k

Décomposition du Brier : Brier = fiabilité (calibration) − résolution + incertitude, avec incertitude = ȳ(1 − ȳ)

MAE = (1/n)Σ|e_i| ; RMSE = √((1/n)Σ e_i²) ≥ MAE ; MAPE = (100/n)Σ|e_i/y_i| ; sMAPE = (200/n)Σ|e_i|/(|y_i|+|ŷ_i|) ; R² = 1 − Σe_i²/Σ(y_i − ȳ)²

Perte pinball (quantile τ) : ℓ_τ(e) = τ·e si e ≥ 0, (τ − 1)·e sinon ; MASE = MAE / MAE de la prévision naïve (saisonnière)

Couverture conforme : avec un score de non-conformité s et le quantile q̂ des scores de calibration au niveau ⌈(n+1)(1−α)⌉/n, l’ensemble {y : s(x, y) ≤ q̂} contient y avec probabilité ≥ 1 − α

Fiche de cours · Formules

Formulaire général (2/2) : classement, texte, LLM, systèmes, statistique

P@k = |pertinents ∩ top-k|/k ; R@k = |pertinents ∩ top-k|/|pertinents| ; MRR = moyenne de 1/rang du premier pertinent ; AP = moyenne des P@k aux rangs pertinents ; MAP = moyenne des AP ; nDCG@k = DCG@k/IDCG@k, DCG = Σ (2^rel_i − 1)/log₂(i+1)

BLEU = BP · exp(Σ_n=1⁴ ¼ log p_n), p_n = précision modifiée des n-grammes (comptes plafonnés par la référence), BP = min(1, e^{1 − r/c})

ROUGE-N = rappel des n-grammes ; ROUGE-L = LCS ; chrF = F_β sur les n-grammes de caractères (β = 2) ; BERTScore = F1 des similarités cosinus token à token (plongements contextuels)

pass@k = E_problèmes[1 − C(n − c, k)/C(n, k)] (n échantillons, c corrects) — estimateur sans biais de Chen et al. 2021

Exact match, F1 token (QA extractive) ; perplexité = e^{−(1/N)Σ log p} (L27)

Elo : E_A = 1/(1 + 10^{(R_B − R_A)/400}), R_A ← R_A + K(S_A − E_A) ; Bradley-Terry : P(A ≻ B) = σ(r_A − r_B) ajusté par vraisemblance (L27)

Kappa de Cohen κ = (p_o − p_e)/(1 − p_e) ; alpha de Krippendorff (multi-annotateurs, données manquantes) ; corrélation de Spearman ρ entre juge et humains

IoU = |A ∩ B|/|A ∪ B| ; mAP@[.5:.95] = moyenne des AP par classe et par seuil d’IoU ; DER = (faux + manqué + confusion)/durée

Parité démographique : P(ŷ = 1 | g) égal entre groupes ; égalité des chances : TPR égal ; odds égalisés : TPR et FPR égaux ; calibration par groupe : P(y = 1 | p̂, g) = p̂

Bootstrap : B rééchantillonnages avec remise du jeu de test → distribution de la métrique → IC percentile [2,5 %, 97,5 %] ; apparié : rééchantillonner les mêmes exemples pour A et B et regarder la différence

McNemar (deux classifieurs, même test) : χ² = (b − c)²/(b + c), b et c = désaccords ; corrections multiples : Bonferroni α/m, Holm, Benjamini-Hochberg

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire (1/2)

Théorème 1 (AUC = probabilité de bon ordonnancement). L’aire sous la courbe ROC égale P(s(X⁺) > s(X⁻)) pour un positif et un négatif tirés au hasard (avec ½ pour les égalités) — c’est la statistique U de Mann-Whitney normalisée.

Paramétrons la ROC par le seuil t : FPR(t) = P(s(X⁻) > t), TPR(t) = P(s(X⁺) > t). AUC = ∫ TPR d(FPR). Avec F⁻ la fonction de répartition des scores négatifs, FPR = 1 − F⁻(t), d(FPR) = −f⁻(t)dt ; AUC = ∫ P(s(X⁺) > t) f⁻(t) dt = E_t∼s(X⁻)[P(s(X⁺) > t)] = P(s(X⁺) > s(X⁻)) par indépendance. Conséquences : l’AUC est invariante par toute transformation croissante des scores (elle ne juge que l’ordre) ; 0,5 = hasard ; elle ne dépend pas de la prévalence — ce qui est une force (comparer des jeux) et une faiblesse (sur des classes très déséquilibrées, une AUC de 0,95 peut cacher une précision de 5 % : regarder la courbe précision-rappel).

Théorème 2 (décomposition du score de Brier). En regroupant les prédictions par valeur de probabilité annoncée p_b (bins) avec fréquences observées o_b et effectifs n_b : Brier = Σ_b (n_b/n)(p_b − o_b)² − Σ_b (n_b/n)(o_b − ȳ)² + ȳ(1 − ȳ) = fiabilité − résolution + incertitude.

Dans le bin b, Σ_i∈b (p_b − y_i)² = n_b(p_b − o_b)² + Σ_i∈b(o_b − y_i)² (développer autour de la moyenne o_b ; le terme croisé s’annule car Σ_i∈b(y_i − o_b) = 0) ; et Σ_i∈b(o_b − y_i)² = n_bo_b(1 − o_b) pour des y binaires. Sommer sur b et diviser par n donne fiabilité + Σ(n_b/n)o_b(1 − o_b). Enfin, la décomposition de la variance de y (L11) : ȳ(1 − ȳ) = Σ(n_b/n)o_b(1 − o_b) + Σ(n_b/n)(o_b − ȳ)², d’où le résultat. Lecture : un bon modèle a une fiabilité nulle (calibré) et une résolution élevée (ses probabilités séparent les cas) ; l’incertitude est irréductible. Un modèle constant p = ȳ est parfaitement calibré et inutile (résolution 0).

Théorème 3 (le log-loss et le Brier sont des règles de score propres ; l’exactitude ne l’est pas).

Soit q la vraie probabilité de y = 1 et p l’annonce. Log-loss attendu : −[q log p + (1 − q) log(1 − p)] ; dérivée en p : −q/p + (1 − q)/(1 − p) = 0 ⇔ p = q, et la fonction est convexe : minimum unique en p = q. Brier attendu : q(1 − p)² + (1 − q)p² ; dérivée −2q(1 − p) + 2(1 − q)p = 0 ⇔ p = q. Exactitude au seuil ½ : annoncer p = 1 dès que q > ½ donne la même exactitude que p = q ; elle n’incite pas à révéler q — d’où les modèles sur-confiants sélectionnés sur l’exactitude.

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire (2/2)

Théorème 4 (pass@k : estimateur sans biais). Si un modèle produit n échantillons dont c sont corrects pour un problème, alors 1 − C(n − c, k)/C(n, k) est un estimateur sans biais de la probabilité qu’au moins un parmi k échantillons (tirés sans remise parmi les n) soit correct — et estime pass@k mieux que 1 − (1 − c/n)^k.

Tirer k parmi les n sans remise : le nombre de sous-ensembles ne contenant aucun correct est C(n − c, k) sur C(n, k) au total ; la probabilité qu’au moins un soit correct est donc exactement 1 − C(n − c, k)/C(n, k), pour ce problème. En moyennant sur les problèmes, on estime pass@k. L’estimateur naïf 1 − (1 − p̂)^k avec p̂ = c/n est biaisé (fonction non linéaire d’une estimation) et surestime pour les petits n. Calcul numérique stable : Π_i=n−c+1ⁿ (1 − k/i) pour le quotient (Chen et al. 2021, Codex).

Théorème 5 (F1 est une moyenne harmonique ; conséquence). F1 = 2PR/(P + R) ≤ min(P, R)·2/(1 + min/max) ≤ √(PR) ≤ (P + R)/2 : elle est dominée par la plus petite des deux ; F1 = 0 dès que P = 0 ou R = 0.

Inégalité des moyennes harmonique ≤ géométrique ≤ arithmétique (pour deux nombres positifs : 2PR/(P+R) ≤ √(PR) ⇔ 4PR ≤ (P+R)² ⇔ 0 ≤ (P−R)²). Si P = 0,99 et R = 0,10 : F1 = 0,18 — la moyenne arithmétique (0,55) aurait masqué l’échec. C’est pourquoi F1 sert pour les classes rares : un modèle qui ne prédit jamais la classe rare a R = 0 et F1 = 0 malgré 99 % d’exactitude. F_β pondère : β > 1 privilégie le rappel (obstacles), β < 1 la précision (spam).

Théorème 6 (BLEU sans pénalité de brièveté est trivialement maximisable). Sans BP, une hypothèse réduite à un seul n-gramme présent dans la référence obtient p_n = 1 pour tout n ≤ sa longueur.

Les précisions modifiées comptent les n-grammes de l’hypothèse présents dans la référence, divisés par le nombre de n-grammes de l’hypothèse ; une hypothèse de 4 mots copiés de la référence a p₁ = p₂ = p₃ = p₄ = 1. La pénalité BP = e^{1 − r/c} (r longueur de référence, c de l’hypothèse) punit c < r exponentiellement. Plus généralement, BLEU récompense la coïncidence lexicale, pas le sens : deux traductions correctes avec des mots différents ont un BLEU faible entre elles ; un BLEU de 40 n’a de sens que sur le même jeu, avec la même tokenisation (sacreBLEU). D’où chrF (caractères, robuste à la morphologie), BERTScore et COMET (appris sur des jugements humains) — et l’évaluation humaine comme référence.

Théorème 7 (kappa corrige l’accord dû au hasard). Si deux annotateurs répondent indépendamment au hasard avec des marginales fixées, leur accord observé p_o vaut en moyenne p_e = Σ_c P₁(c)P₂(c), et κ = 0 ; κ = 1 pour un accord parfait.

Indépendance : P(les deux choisissent c) = P₁(c)P₂(c) ; sommer sur les classes donne l’accord attendu p_e. κ = (p_o − p_e)/(1 − p_e) normalise l’excès d’accord par le maximum possible. Avec une classe à 95 %, deux annotateurs aléatoires s’accordent 90,5 % du temps : un « accord de 92 % » n’est que κ ≈ 0,16. Repères : κ < 0,4 faible, 0,4–0,6 modéré, 0,6–0,8 substantiel, > 0,8 presque parfait. Un LLM-juge se valide de la même façon : κ (ou ρ de Spearman) contre des annotateurs humains, sur un échantillon représentatif, par tranche.

01 / Classification

Matrice de confusion, seuils, ROC et précision-rappel : tout implémenté

import numpy as np
rng = np.random.default_rng(0)
# Détecteur d'obstacles : 2 000 cas, 5 % de positifs ; scores bruités
n = 2000; y = (rng.random(n) < 0.05).astype(int); s = np.where(y == 1, rng.normal(1.6, 1, n), rng.normal(0, 1, n))
def confusion(y, yhat): VP = ((y==1)&(yhat==1)).sum(); FP = ((y==0)&(yhat==1)).sum(); FN = ((y==1)&(yhat==0)).sum(); VN = ((y==0)&(yhat==0)).sum(); return VP, FP, FN, VN
def metriques(y, yhat):
    VP, FP, FN, VN = confusion(y, yhat); P = VP / max(1, VP + FP); R = VP / max(1, VP + FN)
    F1 = 2 * P * R / max(1e-12, P + R); acc = (VP + VN) / len(y)
    mcc = (VP*VN - FP*FN) / max(1e-12, np.sqrt(float((VP+FP)*(VP+FN)*(VN+FP)*(VN+FN))))
    return dict(exactitude=acc, precision=P, rappel=R, F1=F1, MCC=mcc, specificite=VN / max(1, VN + FP))
print("seuil   exact.  préc.  rappel   F1    MCC   spéc.")
for t in (-1.0, 0.0, 0.8, 1.5, 2.5, 99):
    m = metriques(y, (s > t).astype(int)); print(f"{t:5.1f}  {m['exactitude']:6.3f} {m['precision']:6.3f} {m['rappel']:6.3f} {m['F1']:6.3f} {m['MCC']:6.3f} {m['specificite']:6.3f}")
print("→ 'ne jamais détecter' (seuil 99) donne 95 % d'exactitude et F1 = MCC = 0 : l'exactitude ment sous déséquilibre.")
def roc_auc(y, s):
    o = np.argsort(-s); ys = y[o]; tp = np.cumsum(ys); fp = np.cumsum(1 - ys); tpr = tp / ys.sum(); fpr = fp / (1 - ys).sum()
    return np.trapz(np.r_[0, tpr], np.r_[0, fpr]), fpr, tpr
def average_precision(y, s):
    o = np.argsort(-s); ys = y[o]; tp = np.cumsum(ys); prec = tp / np.arange(1, len(ys) + 1); rec = tp / ys.sum()
    return np.sum(np.diff(np.r_[0, rec]) * prec), rec, prec
auc, fpr, tpr = roc_auc(y, s); ap, rec, prec = average_precision(y, s)
# Théorème 1 : AUC = P(s+ > s−), vérifié par Mann-Whitney
paires = np.mean([(sp > sn) + 0.5 * (sp == sn) for sp in s[y == 1][:150] for sn in s[y == 0][:400]])
print(f"\nROC-AUC = {auc:.3f} ; P(s+ > s−) estimé = {paires:.3f} ; AP (PR-AUC) = {ap:.3f} ; AP du hasard = prévalence = {y.mean():.3f}")
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 2, figsize=(9, 3.2)); ax[0].plot(fpr, tpr); ax[0].plot([0, 1], [0, 1], "--", c="gray"); ax[0].set_title(f"ROC (AUC {auc:.2f})"); ax[0].set_xlabel("FPR"); ax[0].set_ylabel("TPR")
ax[1].plot(rec, prec); ax[1].axhline(y.mean(), ls="--", c="gray"); ax[1].set_title(f"précision-rappel (AP {ap:.2f})"); ax[1].set_xlabel("rappel"); ax[1].set_ylabel("précision"); plt.tight_layout(); plt.show()

Choisir le seuil par le coût métier : minimiser C_FN·FN(t) + C_FP·FP(t). Si rater un obstacle coûte 100× une fausse alerte, le seuil optimal est bas (rappel élevé), et F₂ ou le rappel à précision fixée sont les métriques à suivre — pas l’exactitude, ni même F1.

01 / Classification

Multi-classes : micro, macro, pondéré, top-k, et lecture d’une matrice

import numpy as np
rng = np.random.default_rng(1)
classes = ["sol", "mur", "obstacle", "humain", "vide"]; K = len(classes); prev = np.array([0.5, 0.25, 0.12, 0.03, 0.10])
y = rng.choice(K, 3000, p=prev)
# Modèle simulé : bon sur les classes fréquentes, confond humain ↔ obstacle
probs = rng.dirichlet(np.ones(K) * 0.3, 3000); probs[np.arange(3000), y] += 2.0
probs[y == 3, 2] += 1.5                                                    # humains souvent pris pour des obstacles
probs /= probs.sum(1, keepdims=True); yhat = probs.argmax(1)
M = np.zeros((K, K), int)
for a, b in zip(y, yhat): M[a, b] += 1
print("matrice de confusion (lignes = vrai, colonnes = prédit)\n" + "         " + " ".join(f"{c[:5]:>6s}" for c in classes))
for i, c in enumerate(classes): print(f"{c:9s}" + " ".join(f"{v:6d}" for v in M[i]))
P = np.diag(M) / np.maximum(1, M.sum(0)); R = np.diag(M) / np.maximum(1, M.sum(1)); F1 = 2 * P * R / np.maximum(1e-12, P + R); support = M.sum(1)
print("\nclasse     préc.  rappel   F1   support")
for i, c in enumerate(classes): print(f"{c:9s} {P[i]:6.2f} {R[i]:6.2f} {F1[i]:6.2f} {support[i]:7d}")
micro = np.diag(M).sum() / M.sum(); macro = F1.mean(); pond = (F1 * support).sum() / support.sum()
print(f"\nmicro-F1 (= exactitude) {micro:.3f} | macro-F1 {macro:.3f} | F1 pondérée {pond:.3f}")
print("→ la macro révèle l'échec sur 'humain' (3 % des données, mais la classe qui compte pour la sécurité) que la micro cache.")
topk = np.mean([y[i] in np.argsort(-probs[i])[:2] for i in range(3000)]); print(f"top-2 exactitude {topk:.3f} (utile quand plusieurs propositions sont acceptables)")

02 / Calibration et incertitude

Brier, ECE, diagramme de fiabilité, température, et prédiction conforme

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(2)
n = 5000; q = rng.beta(2, 2, n); y = (rng.random(n) < q).astype(int)          # vraie probabilité q, étiquette tirée selon q
def surconfiant(q, T=0.4): z = np.log(q / (1 - q)) / T; return 1 / (1 + np.exp(-z))   # logits divisés par T < 1 : probabilités poussées vers 0/1
p_cal, p_sur = q, surconfiant(q)
def brier(p, y): return np.mean((p - y) ** 2)
def ece(p, y, bins=10):
    e, edges = 0.0, np.linspace(0, 1, bins + 1); comp = []
    for a, b in zip(edges, edges[1:]):
        m = (p > a) & (p <= b)
        if m.any(): e += m.mean() * abs(y[m].mean() - p[m].mean()); comp.append((p[m].mean(), y[m].mean(), m.sum()))
    return e, comp
def logloss(p, y): p = np.clip(p, 1e-12, 1 - 1e-12); return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
for nom, p in (("calibré", p_cal), ("sur-confiant", p_sur)):
    e, _ = ece(p, y); print(f"{nom:13s} Brier {brier(p, y):.4f}  log-loss {logloss(p, y):.4f}  ECE {e:.3f}  exactitude {np.mean((p > 0.5) == y):.3f}  AUC identique (même ordre)")
# Théorème 2 : décomposition du Brier (fiabilité − résolution + incertitude)
def decomposition(p, y, bins=10):
    edges = np.linspace(0, 1, bins + 1); fiab = reso = 0.0; ybar = y.mean()
    for a, b in zip(edges, edges[1:]):
        m = (p > a) & (p <= b)
        if m.any(): fiab += m.mean() * (p[m].mean() - y[m].mean()) ** 2; reso += m.mean() * (y[m].mean() - ybar) ** 2
    return fiab, reso, ybar * (1 - ybar)
f, r, u = decomposition(p_sur, y); print(f"\nsur-confiant : fiabilité {f:.4f} − résolution {r:.4f} + incertitude {u:.4f} = {f - r + u:.4f} ≈ Brier {brier(p_sur, y):.4f}")
# Remède : température (scaling) ajustée sur un jeu de validation par minimisation du log-loss
Ts = np.linspace(0.3, 3, 100); z = np.log(p_sur / (1 - p_sur)); T_best = Ts[np.argmin([logloss(1 / (1 + np.exp(-z / T)), y) for T in Ts])]
p_temp = 1 / (1 + np.exp(-z / T_best)); print(f"température optimale T = {T_best:.2f} → ECE {ece(p_temp, y)[0]:.3f}, Brier {brier(p_temp, y):.4f}")
# Prédiction conforme : ensembles de prédiction avec garantie de couverture 1 − α, sans hypothèse sur le modèle
alpha = 0.1; cal, test = slice(0, 2500), slice(2500, None)
scores = 1 - np.where(y[cal] == 1, p_sur[cal], 1 - p_sur[cal])                       # non-conformité = 1 − p(classe vraie)
qhat = np.quantile(scores, np.ceil((2500 + 1) * (1 - alpha)) / 2500)
ens = [(1 - p_sur[test] <= qhat), (p_sur[test] <= qhat)]                            # inclure la classe 1 si 1−p ≤ q̂ ; la classe 0 si p ≤ q̂
couvre = np.where(y[test] == 1, ens[0], ens[1]).mean(); taille = (ens[0].astype(int) + ens[1]).mean()
print(f"conforme (α = 0,1) : couverture {couvre:.3f} (garantie ≥ 0,90), taille moyenne des ensembles {taille:.2f} — même avec un modèle sur-confiant")
fig, ax = plt.subplots(figsize=(4.2, 3.4)); ax.plot([0, 1], [0, 1], "--", c="gray")
for nom, p in (("calibré", p_cal), ("sur-confiant", p_sur), ("après température", p_temp)):
    _, comp = ece(p, y); ax.plot([c[0] for c in comp], [c[1] for c in comp], "o-", label=nom)
ax.set_xlabel("confiance annoncée"); ax.set_ylabel("fréquence observée"); ax.set_title("diagramme de fiabilité"); ax.legend(fontsize=8); plt.tight_layout(); plt.show()

03 / Régression et séries

MAE, RMSE, MAPE, R², pinball, MASE : ce que chacune récompense

import numpy as np
rng = np.random.default_rng(3)
y = np.abs(rng.normal(50, 20, 500)) + 1; e = rng.normal(0, 5, 500); e[::50] += 60                 # 2 % de grosses erreurs (valeurs aberrantes)
yhat_A = y + e                                                                                    # modèle A : petites erreurs + rares grosses
yhat_B = y + rng.normal(0, 9, 500)                                                                 # modèle B : erreurs moyennes partout
def metr(y, yhat):
    err = yhat - y; return dict(MAE=np.mean(np.abs(err)), RMSE=np.sqrt(np.mean(err**2)), MAPE=100*np.mean(np.abs(err/y)), sMAPE=200*np.mean(np.abs(err)/(np.abs(y)+np.abs(yhat))), R2=1 - np.sum(err**2)/np.sum((y-y.mean())**2), mediane_AE=np.median(np.abs(err)))
for nom, yh in (("A (rares grosses erreurs)", yhat_A), ("B (erreurs moyennes)", yhat_B)):
    m = metr(y, yh); print(f"{nom:26s} " + " ".join(f"{k} {v:6.2f}" for k, v in m.items()))
print("→ MAE préfère A, RMSE préfère B : RMSE pénalise les grosses erreurs quadratiquement. Choisir selon le coût : une erreur de 60 cm sur un robot est-elle 12× ou 144× pire que 5 cm ?")
# MAPE explose près de zéro et est asymétrique ; pinball pour les quantiles ; MASE pour comparer à la prévision naïve
y_petit = np.array([0.5, 1.0, 100.0]); print(f"\nMAPE avec y = 0,5 et erreur 1 : {100*abs(1/0.5):.0f} % — une seule petite valeur domine ; sMAPE bornée à 200 %")
def pinball(y, q_hat, tau): d = y - q_hat; return np.mean(np.maximum(tau * d, (tau - 1) * d))
q90 = np.quantile(y, 0.9); print(f"pinball τ=0,9 pour la prévision constante q90 : {pinball(y, q90, 0.9):.2f} ; pour la médiane : {pinball(y, np.median(y), 0.9):.2f} (le quantile juste minimise la pinball)")
serie = np.cumsum(rng.normal(0, 1, 200)) + 10 * np.sin(np.arange(200) / 7); naive = serie[:-1]; prev = serie[1:] + rng.normal(0, 0.8, 199)
mase = np.mean(np.abs(prev - serie[1:])) / np.mean(np.abs(naive - serie[1:])); print(f"MASE = {mase:.2f} (< 1 : mieux que la prévision naïve 'demain = aujourd'hui' ; > 1 : le modèle ne sert à rien)")

Sur des séries temporelles : jamais de séparation aléatoire (fuite du futur), toujours une validation glissante (entraîner jusqu’à t, tester sur t+1..t+h, avancer), et toujours la baseline naïve (MASE) — beaucoup de modèles publiés ne la battent pas (Makridakis, M4).

04 / Classement et recherche

P@k, R@k, MRR, MAP, nDCG — et les métriques de contexte pour le RAG

import numpy as np
# Jeu : 4 requêtes, classements produits par deux systèmes, pertinences graduées (0..3)
verite = {"q1": {"d3": 3, "d7": 2, "d1": 1}, "q2": {"d2": 3}, "q3": {"d5": 2, "d6": 2, "d9": 1, "d4": 1}, "q4": {"d8": 3, "d2": 1}}
sysA = {"q1": ["d3", "d1", "d4", "d7", "d9"], "q2": ["d4", "d2", "d1", "d3", "d5"], "q3": ["d5", "d6", "d9", "d4", "d1"], "q4": ["d1", "d3", "d5", "d8", "d2"]}
sysB = {"q1": ["d7", "d3", "d1", "d2", "d4"], "q2": ["d2", "d1", "d4", "d3", "d5"], "q3": ["d4", "d1", "d2", "d5", "d3"], "q4": ["d8", "d2", "d4", "d1", "d3"]}
def p_at_k(cl, rel, k): return sum(1 for d in cl[:k] if d in rel) / k
def r_at_k(cl, rel, k): return sum(1 for d in cl[:k] if d in rel) / len(rel)
def mrr(cl, rel): return next((1 / (i + 1) for i, d in enumerate(cl) if d in rel), 0.0)
def ap(cl, rel): hits = 0; s = 0.0
def ap(cl, rel):
    hits, s = 0, 0.0
    for i, d in enumerate(cl):
        if d in rel: hits += 1; s += hits / (i + 1)
    return s / len(rel)
def ndcg(cl, rel, k):
    dcg = sum((2 ** rel.get(d, 0) - 1) / np.log2(i + 2) for i, d in enumerate(cl[:k])); ideal = sorted(rel.values(), reverse=True)[:k]
    return dcg / sum((2 ** g - 1) / np.log2(i + 2) for i, g in enumerate(ideal))
print(f"{'système':8s} {'P@3':>6s} {'R@3':>6s} {'MRR':>6s} {'MAP':>6s} {'nDCG@3':>7s} {'nDCG@5':>7s}")
for nom, S in (("A", sysA), ("B", sysB)):
    v = [np.mean([f(S[q], verite[q]) for q in verite]) for f in (lambda c, r: p_at_k(c, r, 3), lambda c, r: r_at_k(c, r, 3), mrr, ap, lambda c, r: ndcg(c, r, 3), lambda c, r: ndcg(c, r, 5))]
    print(f"{nom:8s} " + " ".join(f"{x:6.3f}" for x in v))
print("→ A et B se classent différemment selon la métrique : MRR ne voit que le premier pertinent, nDCG pondère par position et gain, R@k ignore l'ordre.")
# Métriques de contexte pour un RAG (par requête : les k morceaux fournis au LLM)
def precision_contexte(fournis, rel): return np.mean([d in rel for d in fournis])          # fraction des morceaux fournis qui sont utiles
def rappel_contexte(fournis, rel): return np.mean([d in fournis for d in rel])             # fraction de l'information nécessaire présente
for nom, S in (("A", sysA), ("B", sysB)):
    pc = np.mean([precision_contexte(S[q][:3], verite[q]) for q in verite]); rc = np.mean([rappel_contexte(S[q][:3], verite[q]) for q in verite])
    print(f"RAG avec {nom}, k = 3 : précision du contexte {pc:.2f} (bruit fourni au modèle), rappel du contexte {rc:.2f} (plafond de l'exactitude, L26)")

05 / Génération de texte

BLEU, chrF, ROUGE, exact match/F1, pass@k — implémentés, avec leurs pathologies

import numpy as np, re
from collections import Counter
from math import comb, exp, log
def ngrams(toks, n): return Counter(tuple(toks[i:i+n]) for i in range(len(toks) - n + 1))
def bleu(hyp, ref, N=4):
    h, r = hyp.split(), ref.split(); logs = []
    for n in range(1, N + 1):
        hn, rn = ngrams(h, n), ngrams(r, n); tot = max(1, sum(hn.values())); match = sum(min(c, rn[g]) for g, c in hn.items())
        logs.append(log(max(match, 1e-9) / tot))
    bp = 1.0 if len(h) >= len(r) else exp(1 - len(r) / max(1, len(h)))
    return bp * exp(np.mean(logs))
def chrf(hyp, ref, n_max=6, beta=2):
    h, r = hyp.replace(" ", ""), ref.replace(" ", ""); P = R = 0
    for n in range(1, n_max + 1):
        hn, rn = ngrams(list(h), n), ngrams(list(r), n); m = sum(min(c, rn[g]) for g, c in hn.items())
        P += m / max(1, sum(hn.values())); R += m / max(1, sum(rn.values()))
    P, R = P / n_max, R / n_max; return (1 + beta**2) * P * R / max(1e-9, beta**2 * P + R)
def rouge_l(hyp, ref):
    h, r = hyp.split(), ref.split(); D = [[0] * (len(r) + 1) for _ in range(len(h) + 1)]
    for i in range(len(h)):
        for j in range(len(r)): D[i+1][j+1] = D[i][j] + 1 if h[i] == r[j] else max(D[i][j+1], D[i+1][j])
    lcs = D[-1][-1]; P, R = lcs / max(1, len(h)), lcs / max(1, len(r)); return 2 * P * R / max(1e-9, P + R)
def norm(s): return " ".join(re.sub(r"[^\w\s]", "", s.lower()).split())
def exact_match(h, r): return float(norm(h) == norm(r))
def f1_token(h, r):
    hc, rc = Counter(norm(h).split()), Counter(norm(r).split()); m = sum((hc & rc).values())
    if m == 0: return 0.0
    P, R = m / sum(hc.values()), m / sum(rc.values()); return 2 * P * R / (P + R)
ref = "le robot s'arrête devant l'obstacle et attend l'ordre suivant"
hyps = {"correcte, mêmes mots": "le robot s'arrête devant l'obstacle et attend l'ordre suivant", "correcte, reformulée": "face à l'obstacle, le robot stoppe puis attend la prochaine instruction",
        "fausse, mêmes mots": "le robot ne s'arrête pas devant l'obstacle et attend l'ordre suivant", "tronquée (4 mots)": "le robot s'arrête devant"}
print(f"{'hypothèse':24s} {'BLEU':>6s} {'chrF':>6s} {'ROUGE-L':>8s} {'EM':>4s} {'F1tok':>6s}")
for nom, h in hyps.items(): print(f"{nom:24s} {bleu(h, ref):6.3f} {chrf(h, ref):6.3f} {rouge_l(h, ref):8.3f} {exact_match(h, ref):4.0f} {f1_token(h, ref):6.3f}")
print("→ 'fausse, mêmes mots' (une négation !) bat 'correcte, reformulée' sur toutes les métriques lexicales : elles mesurent le recouvrement, pas le sens.")
# pass@k (Théorème 4) : estimateur sans biais vs naïf
def pass_at_k(n, c, k): return 1.0 if n - c < k else 1 - np.prod([1 - k / i for i in range(n - c + 1, n + 1)])
n, c = 10, 3; print(f"\nn = {n} échantillons, {c} corrects : pass@1 {pass_at_k(n, c, 1):.3f}, pass@5 {pass_at_k(n, c, 5):.3f} (sans biais) vs naïf 1−(1−c/n)^5 = {1 - (1 - c/n)**5:.3f}")

06 / LLM et benchmarks

Lire un classement : ce que mesurent MMLU, GSM8K, HumanEval, MT-Bench, l’Arena — et ce qui les fausse

Benchmark	Mesure	Format / métrique	Pièges connus
MMLU (57 matières)	Connaissances académiques	QCM 4 choix, exactitude, 5-shot	Sensible au format des choix (A/B/C/D vs texte), contamination, erreurs dans les questions (~6 %) ; saturé (MMLU-Pro)
GSM8K / MATH	Raisonnement arithmétique / mathématique	Réponse finale, exactitude, CoT	Contamination massive (versions reformulées GSM1k montrent des baisses de 10 points) ; extraction de la réponse fragile
HumanEval / MBPP	Génération de code	pass@k sur tests unitaires	164 problèmes seulement ; tests incomplets ; contamination ; EvalPlus ajoute des tests
HellaSwag, ARC, WinoGrande	Sens commun	QCM, log-vraisemblance des choix	Artefacts d’annotation exploitables sans lire la question
MT-Bench, AlpacaEval	Qualité conversationnelle	LLM-juge (GPT-4) note ou compare	Biais de longueur, biais de position, auto-préférence du juge ; AlpacaEval 2 corrige la longueur
Chatbot Arena	Préférence humaine en aveugle	Comparaisons par paires → Elo/Bradley-Terry	Population d’utilisateurs non représentative ; prompts courts ; style récompensé ; possibilité de manipulation
BIG-bench, HELM	Large couverture, multi-métriques	Nombreuses tâches, exactitude + calibration + robustesse + équité + efficacité	Coût ; agrégation discutable
SWE-bench, GAIA, WebArena	Agents (code, web, outils)	Taux de résolution de tâches réelles	Coût ; variance élevée ; fuite de solutions sur GitHub

import numpy as np
rng = np.random.default_rng(4)
# Deux faits chiffrés à retenir. 1) La variance de prompt : le même modèle sur MMLU avec 6 formats de QCM.
formats = rng.normal(0, 2.5, 6) + 68.0; print("MMLU du même modèle selon le format des choix :", formats.round(1), f"→ étendue {formats.max()-formats.min():.1f} points : un classement à 1 point près est du bruit")
# 2) Contamination : baisse de score sur un jeu reformulé (GSM1k-like) proportionnelle à la mémorisation
modeles = {"modèle X": (84.2, 71.5), "modèle Y": (79.8, 78.9), "modèle Z": (88.0, 66.0)}
print("\nmodèle    GSM8K  GSM8K-reformulé  écart  (écart > 5 : suspicion de contamination)")
for m, (a, b) in modeles.items(): print(f"{m:9s} {a:6.1f} {b:15.1f} {a-b:6.1f}  {'⚠' if a - b > 5 else 'ok'}")
print("\nRègles : 1) rapporter le format exact et le nombre de shots ; 2) tester sur une version privée/reformulée ; 3) comparer à budget de prompt égal ;")
print("4) préférer des jeux de test PRIVÉS pour votre usage (vos 500 questions) : les classements publics mesurent la course aux classements.")

07 / RAG, prompts, agents

Évaluer un système composé : par composant, puis bout en bout

Composant	Métriques	Comment	Référence
Découpage + index (RAG)	R@k, nDCG, précision de contexte	Jeu de questions → morceaux pertinents annotés	L26
Génération (RAG)	Fidélité, pertinence réponse, exactitude, citations valides, refus corrects	Juge (humain/LLM) par affirmation ; vérification syntaxique des citations	RAGAS, ARES
Prompt	Exactitude, format valide, dispersion inter-formulations, coût/tokens	Banc d’essai versionné, graines	L28
Agent (outils, multi-étapes)	Taux de réussite de tâche, pas moyens, coût, taux de boucles/abandons, actions dangereuses, robustesse aux erreurs d’outils	Environnements reproductibles (bac à sable), tâches avec vérificateur automatique	SWE-bench, GAIA, τ-bench
Sécurité	Taux de compromission (injection), taux de refus légitime/illégitime (sur-refus), fuite de données	Corpus adverses, red teaming	OWASP LLM Top 10, HarmBench
Expérience utilisateur	Satisfaction (CSAT), taux d’escalade vers un humain, temps de résolution, taux de reformulation	Télémétrie en production, A/B	L35

import numpy as np
rng = np.random.default_rng(5)
# Un agent évalué sur 200 tâches × 5 graines : succès, pas, coût. Ce qu'il faut rapporter.
succes = rng.random((5, 200)) < 0.62; pas = rng.integers(3, 25, (5, 200)); cout = pas * 0.004 + rng.normal(0, 0.005, (5, 200))
taux = succes.mean(1); print(f"taux de réussite par graine : {taux.round(3)} → {taux.mean():.3f} ± {taux.std(ddof=1)/np.sqrt(5):.3f} (erreur standard)")
print(f"pas moyens (succès) {pas[succes].mean():.1f} vs (échecs) {pas[~succes].mean():.1f} — les échecs bouclent ; coût moyen par tâche {cout.mean():.3f} €, p95 {np.percentile(cout, 95):.3f} €")
pass_all = succes.all(0).mean(); pass_any = succes.any(0).mean(); print(f"réussite sur les 5 graines (fiabilité) : {pass_all:.3f} ; sur au moins une : {pass_any:.3f} → l'écart mesure la NON-DÉTERMINISME de l'agent : à rapporter (pass^k, Yao 2024)")
print("Par tranche : réussite sur les tâches 'faciles' (< 5 outils)", succes[:, :100].mean().round(3), "vs 'difficiles'", succes[:, 100:].mean().round(3), "(simulé : à annoter pour de vrai)")

08 / Perception

OCR, ASR, vision : CER/WER, IoU, mAP, DER, et métriques d’image

import numpy as np
# IoU et mAP simplifiée pour la détection (une classe) : appariement glouton par score, seuil IoU 0,5
def iou(a, b):
    x1, y1 = max(a[0], b[0]), max(a[1], b[1]); x2, y2 = min(a[2], b[2]), min(a[3], b[3]); inter = max(0, x2 - x1) * max(0, y2 - y1)
    return inter / ((a[2]-a[0])*(a[3]-a[1]) + (b[2]-b[0])*(b[3]-b[1]) - inter)
verite = [(10, 10, 50, 50), (60, 20, 100, 70), (120, 120, 160, 150)]
preds = [((12, 12, 52, 52), 0.9), ((58, 22, 98, 68), 0.8), ((200, 200, 230, 230), 0.7), ((118, 118, 162, 152), 0.3), ((30, 30, 45, 45), 0.2)]
def ap_detection(verite, preds, seuil=0.5):
    preds = sorted(preds, key=lambda p: -p[1]); pris = set(); tp = []
    for b, s in preds:
        j = max(range(len(verite)), key=lambda i: iou(b, verite[i]) if i not in pris else -1, default=None)
        if j is not None and iou(b, verite[j]) >= seuil: pris.add(j); tp.append(1)
        else: tp.append(0)
    tp = np.array(tp); cum = np.cumsum(tp); prec = cum / np.arange(1, len(tp) + 1); rec = cum / len(verite)
    return np.sum(np.diff(np.r_[0, rec]) * prec), list(zip(prec.round(2), rec.round(2)))
ap50, courbe = ap_detection(verite, preds); ap75, _ = ap_detection(verite, preds, 0.75)
print(f"AP@0.5 = {ap50:.3f}, AP@0.75 = {ap75:.3f} ; courbe (précision, rappel) par prédiction : {courbe}")
print("mAP@[.5:.95] (COCO) = moyenne sur 10 seuils d'IoU et sur les classes : récompense la précision de localisation, pas seulement la présence.")
# DER (diarisation) : durée mal attribuée / durée totale — ici un exemple à 3 segments
ref_seg = [(0, 5, "A"), (5, 8, "B"), (8, 12, "A")]; hyp_seg = [(0, 4, "A"), (4, 9, "B"), (9, 12, "A")]
err = 0.0
for t in np.arange(0, 12, 0.01):
    r = next(s for a, b, s in ref_seg if a <= t < b); h = next(s for a, b, s in hyp_seg if a <= t < b); err += 0.01 * (r != h)
print(f"DER = {err / 12:.3f} (2 s mal attribuées sur 12)")
# Qualité d'image : PSNR / SSIM (idée) — et pourquoi FID pour la génération
rng = np.random.default_rng(6); I = rng.random((32, 32)); J = I + rng.normal(0, 0.05, (32, 32))
mse = np.mean((I - J) ** 2); print(f"PSNR = {10*np.log10(1/mse):.1f} dB (référence nécessaire) ; FID compare des DISTRIBUTIONS de plongements (Inception) entre images générées et réelles — sans référence par image, mais biaisé par la taille d'échantillon (≥ 10 000 images).")

OCR : CER/WER par Levenshtein, exactitude par champ, taux de documents parfaits (L29). ASR : WER normalisé, par condition, sur entités, RTF (L30). Segmentation : IoU par classe, mIoU, Dice = 2|A∩B|/(|A|+|B|). Estimation de pose : ATE/RPE (L20). Toutes ont besoin d’une vérité terrain dont le coût d’annotation est le premier poste du projet (L36).

09 / Robustesse et équité

Hors distribution, perturbations, et métriques d’équité — avec leur incompatibilité

import numpy as np
rng = np.random.default_rng(7)
# 1) Robustesse : écart entre le test i.i.d. et un test décalé (autre capteur, autre saison, bruit) — à mesurer systématiquement
iid, shift, corr = 0.91, 0.74, 0.62
print(f"exactitude i.i.d. {iid:.2f} → décalage de domaine {shift:.2f} (−{100*(iid-shift):.0f} pts) → perturbations (bruit, flou, occlusion) {corr:.2f} ; rapporter la robustesse relative shift/iid = {shift/iid:.2f}")
# 2) Équité : un classifieur de crédit sur deux groupes — calculer parité démographique, égalité des chances, calibration par groupe
n = 20000; g = rng.integers(0, 2, n); base = np.where(g == 0, 0.35, 0.25)                # taux de base différents par groupe
y = (rng.random(n) < base).astype(int); score = 0.6 * y + rng.normal(0, 0.5, n) + 0.05 * g        # score légèrement décalé par groupe
yhat = (score > 0.45).astype(int)
def taux(m): return dict(selection=yhat[m].mean(), TPR=yhat[m][y[m]==1].mean(), FPR=yhat[m][y[m]==0].mean(), precision=y[m][yhat[m]==1].mean())
for grp in (0, 1):
    t = taux(g == grp); print(f"groupe {grp} : taux de sélection {t['selection']:.3f}, TPR {t['TPR']:.3f}, FPR {t['FPR']:.3f}, précision (calibration) {t['precision']:.3f}")
t0, t1 = taux(g == 0), taux(g == 1)
print(f"\nparité démographique : écart de sélection {abs(t0['selection']-t1['selection']):.3f} ; égalité des chances : écart de TPR {abs(t0['TPR']-t1['TPR']):.3f} ; odds égalisés : + écart FPR {abs(t0['FPR']-t1['FPR']):.3f} ; calibration : écart de précision {abs(t0['precision']-t1['precision']):.3f}")
print("Théorème d'impossibilité (Chouldechova 2017, Kleinberg 2016) : si les taux de base diffèrent, on ne peut pas avoir à la fois calibration par groupe, TPR égaux et FPR égaux (sauf classifieur parfait).")
print("Donc : choisir explicitement le critère selon le contexte (et le documenter), mesurer par tranche, et publier les écarts — pas 'le modèle est équitable'.")

Robustesse adverse : mesurer la baisse sous perturbations optimisées (PGD pour la vision, suffixes adverses pour les LLM) ; c’est une borne pessimiste utile pour la sécurité. Hors distribution : rapporter aussi la détection d’OOD (le modèle sait-il qu’il ne sait pas ? AUROC de la confiance entre in/out).

10 / Efficacité et coût

Latence, débit, coût, énergie : les métriques que la production impose

import numpy as np
rng = np.random.default_rng(8)
lat = np.exp(rng.normal(np.log(180), 0.5, 5000)); lat[rng.random(5000) < 0.02] *= 6           # ms ; queue lourde (2 % de requêtes très lentes)
print(f"latence : moyenne {lat.mean():.0f} ms, p50 {np.percentile(lat, 50):.0f}, p95 {np.percentile(lat, 95):.0f}, p99 {np.percentile(lat, 99):.0f}, max {lat.max():.0f} ms")
print("→ la moyenne cache la queue ; un SLO s'écrit 'p95 < 500 ms', et la latence utilisateur d'une page à 10 appels est gouvernée par le p99 de chacun.")
# Coût par requête (tokens), débit, et le coût total d'un service
tok_in, tok_out = 2800, 350; prix_in, prix_out = 0.5, 1.5                        # € par million
c_req = (tok_in * prix_in + tok_out * prix_out) / 1e6; print(f"\ncoût par requête API : {c_req*100:.3f} c€ ; 50 000 requêtes/jour : {c_req*50000:.0f} €/jour, {c_req*50000*365:.0f} €/an")
gpu_h, tps = 2.5, 800                                                              # € par heure GPU, tokens/s en lot
c_local = gpu_h / 3600 / tps * (tok_in * 0.1 + tok_out)                           # préremplissage ~10× moins cher que la génération
print(f"coût local (GPU {gpu_h} €/h, {tps} tok/s) : {c_local*100:.3f} c€/requête si le GPU est saturé ; sinon proportionnellement plus")
print("énergie : ~0,3–0,7 kWh par heure de GPU ; une requête LLM ≈ 0,2–3 Wh (10–100× une recherche web) ; entraînement GPT-3 ≈ 1 300 MWh.")
print("\nMétriques à suivre : latence p50/p95/p99 (par étape : recherche, préremplissage, génération), débit (req/s, tok/s), utilisation GPU, coût/requête, coût/utilisateur actif, taux d'erreur (5xx, timeouts), mémoire, énergie.")

11 / Humains et LLM-juge

Accord inter-annotateurs, Bradley-Terry, et validation d’un LLM-juge

import numpy as np
rng = np.random.default_rng(9)
def kappa(a, b):
    a, b = np.asarray(a), np.asarray(b); K = max(a.max(), b.max()) + 1; po = np.mean(a == b)
    pe = sum((a == c).mean() * (b == c).mean() for c in range(K)); return (po - pe) / (1 - pe)
# Théorème 7 : accord élevé mais kappa faible sous déséquilibre
n = 1000; base = (rng.random(n) < 0.95).astype(int)
ann1 = np.where(rng.random(n) < 0.96, base, 1 - base); ann2 = np.where(rng.random(n) < 0.96, base, 1 - base)
print(f"accord brut {np.mean(ann1 == ann2):.3f}, kappa {kappa(ann1, ann2):.3f} — avec 95 % d'une classe, 92 % d'accord ne vaut pas grand-chose")
# LLM-juge : mesurer son accord avec des humains, ET ses biais (longueur, position)
humain = rng.integers(1, 6, 300); juge = np.clip(humain + rng.integers(-1, 2, 300), 1, 5)
rho = np.corrcoef(np.argsort(np.argsort(humain)), np.argsort(np.argsort(juge)))[0, 1]; print(f"\nSpearman juge/humain : {rho:.3f} (≥ 0,7 acceptable) ; kappa pondéré à calculer aussi")
longueur = rng.integers(50, 400, 300); juge_biaise = np.clip(humain + (longueur > 250) + rng.integers(-1, 2, 300), 1, 5)
print(f"biais de longueur : note moyenne du juge pour réponses longues {juge_biaise[longueur > 250].mean():.2f} vs courtes {juge_biaise[longueur <= 250].mean():.2f} à qualité humaine égale ({humain[longueur > 250].mean():.2f} vs {humain[longueur <= 250].mean():.2f})")
print("Contrôles : permuter l'ordre A/B (biais de position), comparer à longueur contrôlée, juge ≠ modèle évalué (auto-préférence), échantillon humain de 100–300 cas par version.")
# Bradley-Terry sur des comparaisons par paires (Arena) : ajustement par vraisemblance, IC par bootstrap
vrai = np.array([1.2, 0.8, 0.0, -0.5]); paires = [(i, j) for i in range(4) for j in range(4) if i != j]
data = [(i, j, rng.random() < 1 / (1 + np.exp(-(vrai[i] - vrai[j])))) for _ in range(300) for (i, j) in [paires[rng.integers(len(paires))]]]
def bt(data, it=200, lr=2.0):
    r = np.zeros(4)
    for _ in range(it):
        g = np.zeros(4)
        for i, j, w in data: p = 1 / (1 + np.exp(-(r[i] - r[j]))); g[i] += (w - p); g[j] -= (w - p)
        r += lr * g / len(data); r -= r.mean()
    return r
boot = np.array([bt([data[k] for k in rng.integers(len(data), size=len(data))], it=100) for _ in range(30)])
print("\nBradley-Terry : forces estimées", bt(data).round(2), "| vraies", (vrai - vrai.mean()).round(2), "| IC 95 % (bootstrap) demi-largeur ≈", (1.96 * boot.std(0)).round(2))
print("→ avec 300 comparaisons pour 4 modèles, les IC se chevauchent : l'Arena a besoin de dizaines de milliers de votes pour séparer des modèles proches.")

12 / Statistique

Conclure : bootstrap, tests appariés, McNemar, comparaisons multiples

import numpy as np
rng = np.random.default_rng(10)
n = 400; difficulte = rng.random(n)
ok_A = rng.random(n) > difficulte * 0.9; ok_B = rng.random(n) > difficulte * 0.85           # B un peu meilleur, sur les MÊMES cas
print(f"exactitude A {ok_A.mean():.3f}, B {ok_B.mean():.3f}, écart {ok_B.mean()-ok_A.mean():+.3f}")
# 1) Bootstrap NON apparié (faux ici) vs apparié (juste) : l'appariement réduit la variance car les cas sont partagés
B = 2000; idx = rng.integers(n, size=(B, n))
d_app = ok_B[idx].mean(1) - ok_A[idx].mean(1); d_non = ok_B[idx].mean(1) - ok_A[rng.integers(n, size=(B, n))].mean(1)
print(f"IC 95 % de l'écart — apparié : [{np.percentile(d_app, 2.5):+.3f}, {np.percentile(d_app, 97.5):+.3f}] ; non apparié : [{np.percentile(d_non, 2.5):+.3f}, {np.percentile(d_non, 97.5):+.3f}]")
# 2) McNemar : ne regarde que les désaccords
b = np.sum(ok_A & ~ok_B); c = np.sum(~ok_A & ok_B); chi2 = (abs(b - c) - 1) ** 2 / max(1, b + c)
print(f"McNemar : A seul correct {b}, B seul correct {c}, χ² = {chi2:.2f} → {'significatif (χ² > 3,84)' if chi2 > 3.84 else 'non significatif'}")
# 3) Comparaisons multiples : tester 20 variantes contre la baseline avec α = 0,05 quand AUCUNE n'est meilleure
faux = 0
for _ in range(200):
    base = rng.random(n) > difficulte * 0.9; k = 0
    for v in range(20):
        var = rng.random(n) > difficulte * 0.9; bb = np.sum(base & ~var); cc = np.sum(~base & var)
        if (abs(bb - cc) - 1) ** 2 / max(1, bb + cc) > 3.84 and cc > bb: k += 1
    faux += (k > 0)
print(f"\n20 variantes équivalentes testées à α = 5 % : au moins un 'gagnant' dans {faux/2:.0f} % des expériences → correction de Bonferroni (α/20) ou Holm, ou pré-enregistrer UNE hypothèse")
# 4) Taille d'effet et puissance : combien de cas pour détecter +3 points ?
p = 0.75; delta = 0.03; print(f"pour détecter +{100*delta:.0f} points autour de {100*p:.0f} % (puissance 80 %, apparié avec corrélation ~0,5) : n ≈ {int(8 * p * (1-p) / delta**2)} cas ; non apparié : {int(16 * p * (1-p) / delta**2)}")

Le protocole minimal d’une comparaison : même jeu de test, appariement, ≥ 3 graines quand le système est stochastique, IC bootstrap de la différence, test apparié, taille d’effet, hypothèse déclarée avant, et analyse d’erreurs qualitative sur 50 cas. Sans cela, un tableau de chiffres n’est pas un résultat (L24).

Synthèse

Quelle métrique pour quel problème : la table de décision

Situation	Métrique principale	Métriques de contrôle	Ne pas utiliser seule
Classification équilibrée	Exactitude, log-loss	Matrice de confusion, calibration	—
Classe rare, coût asymétrique	Rappel à précision fixée, F_β, PR-AUC	MCC, coût total	Exactitude, ROC-AUC
Décisions probabilistes (seuils, fusion)	Brier, ECE, log-loss	Diagramme de fiabilité par tranche	Exactitude
Régression avec valeurs aberrantes	MAE, médiane	RMSE, quantiles	MAPE, R² seul
Prévision de séries	MASE, pinball	Validation glissante	Séparation aléatoire
Recherche / RAG	R@k, nDCG ; fidélité	Précision de contexte, MRR, latence	Score du LLM seul
Traduction / résumé	Humain, COMET/BERTScore	chrF, BLEU (comparabilité)	BLEU/ROUGE seul
Code	pass@k avec tests étendus	Temps, sécurité	Similarité textuelle
Assistant conversationnel	Réussite de tâche, préférence humaine	LLM-juge validé, sur-refus, latence	MT-Bench seul
Agent	Taux de réussite (pass^k), coût	Pas, boucles, actions dangereuses	Une graine
Détection / segmentation	mAP@[.5:.95], mIoU	Par classe, par taille d’objet	Exactitude par pixel
OCR / ASR	CER/WER normalisés + par champ/entité	Par condition, RTF	Moyenne globale
Tout système déployé	Métrique métier (extrinsèque)	Tranches, robustesse, équité, coût, p95	Un benchmark public

Articles

Les articles à lire

Article	Contribution	À retenir
Hanley & McNeil, The meaning and use of the area under a ROC curve, Radiology 1982	AUC = Mann-Whitney	Théorème 1
Saito & Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot on Imbalanced Datasets, PLoS ONE 2015	PR vs ROC sous déséquilibre	Choisir la courbe selon la prévalence
Guo et al., On Calibration of Modern Neural Networks, ICML 2017 — 1706.04599	Les réseaux profonds sont sur-confiants ; température	ECE, diagrammes de fiabilité
Angelopoulos & Bates, A Gentle Introduction to Conformal Prediction, 2021 — 2107.07511	Garanties de couverture sans hypothèse	Ensembles de prédiction pour la sécurité
Papineni et al., BLEU, ACL 2002 ; Post, A Call for Clarity in Reporting BLEU Scores (sacreBLEU), 2018 — 1804.08771	Métrique lexicale ; standardisation	Théorème 6 ; toujours sacreBLEU
Zhang et al., BERTScore, ICLR 2020 — 1904.09675 ; Rei et al., COMET, 2020	Métriques sémantiques / apprises	Corrélation humaine bien supérieure à BLEU
Chen et al., Evaluating LLMs Trained on Code (Codex), 2021 — 2107.03374	HumanEval, pass@k sans biais	Théorème 4
Liang et al., Holistic Evaluation of Language Models (HELM), 2022 — 2211.09110	Multi-métriques : exactitude, calibration, robustesse, équité, biais, toxicité, efficacité	Un modèle n’a pas « un » score
Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, NeurIPS 2023 — 2306.05685	LLM-juge : accord ~80 % avec les humains ; biais de position, de longueur, d’auto-préférence	Valider le juge, contrôler les biais
Zhang et al., A Careful Examination of LLM Performance on Grade School Arithmetic (GSM1k), 2024 — 2405.00332	Contamination mesurée par un jeu reformulé privé	Écarts jusqu’à 13 points
Sclar et al. 2023 (L28) ; Alzahrani et al., When Benchmarks are Targets, 2024 — 2402.01781	Sensibilité des classements au format	Un point d’écart n’est pas un résultat
Chouldechova, Fair prediction with disparate impact, 2017 — 1610.07524 ; Kleinberg et al., 2016 — 1609.05807	Impossibilité de satisfaire toutes les définitions d’équité	Choisir et documenter
Dror et al., The Hitchhiker’s Guide to Testing Statistical Significance in NLP, ACL 2018	Tests appariés, bootstrap, corrections	Le protocole de la partie 12
Bowman & Dahl, What Will it Take to Fix Benchmarking in NLU?, 2021 — 2104.02145	Validité, fiabilité, saturation des benchmarks	Construire des jeux privés et évolutifs

TP guidé

TP — Le rapport d’évaluation complet (6 h)

Système. Reprendre votre RAG (L26) ou votre classifieur (L13/L31). Écrire d’abord la carte de métriques : objectif métier, métrique principale, métriques de contrôle, tranches, seuils d’acceptation.
Bibliothèque. pip install scikit-learn evaluate sacrebleu jiwer ; réimplémenter 5 métriques à la main et vérifier contre la bibliothèque (le meilleur test de compréhension).
Mesures. Pour deux versions du système : toutes les métriques pertinentes, par tranche, avec bootstrap apparié (2 000 rééchantillonnages), test apparié, taille d’effet. Diagramme de fiabilité si des probabilités sont produites.
Juge. Si un LLM-juge est utilisé : 150 cas jugés par 2 humains (kappa entre eux), puis par le juge (Spearman/kappa avec les humains), test du biais de longueur et de position.
Robustesse et coût. Un jeu décalé (autre source, bruit), 20 cas adverses ; latence p50/p95, coût par requête.
Livrable. Rapport de 6 pages : carte de métriques, tableaux avec IC, figures, analyse d’erreurs (30 cas), décision « déployer / ne pas déployer » argumentée, et les limites de l’évaluation elle-même.

Exercices

Exercices auto-corrigés (1/2)

Exercice 1 — ROC-AUC par Mann-Whitney et invariance

Implémentez auc_mw(y, s) via la statistique U (rangs, avec ½ pour les égalités) et vérifiez le Théorème 1 : égalité avec l’aire trapézoïdale, invariance par transformation croissante, valeur ½ pour des scores aléatoires.

Correction

def auc_mw(y, s):
    y, s = np.asarray(y), np.asarray(s); o = np.argsort(s, kind="mergesort"); r = np.empty(len(s)); r[o] = np.arange(1, len(s) + 1)
    # rangs moyens pour les égalités
    vals, inv, counts = np.unique(s, return_inverse=True, return_counts=True); somme = np.zeros(len(vals)); np.add.at(somme, inv, r); r = (somme / counts)[inv]
    n1, n0 = y.sum(), len(y) - y.sum(); return (r[y == 1].sum() - n1 * (n1 + 1) / 2) / (n1 * n0)

Exercice 2 — ECE et une variante moins fragile

Implémentez ece(p, y, bins) (bins de largeur égale) et ece_adaptatif(p, y, bins) (bins de même effectif, par quantiles). Vérifiez : un modèle parfaitement calibré a une ECE ≈ 0 ; ECE dépend du nombre de bins ; la version adaptative est plus stable quand les probabilités sont concentrées.

Correction

def ece(p, y, bins=10):
    edges = np.linspace(0, 1, bins + 1); e = 0.0
    for a, b in zip(edges, edges[1:]):
        m = (p > a) & (p <= b) if a > 0 else (p >= a) & (p <= b)
        if m.any(): e += m.mean() * abs(y[m].mean() - p[m].mean())
    return e
def ece_adaptatif(p, y, bins=10):
    o = np.argsort(p); e = 0.0
    for idx in np.array_split(o, bins): e += len(idx) / len(p) * abs(y[idx].mean() - p[idx].mean())
    return e

Exercices

Exercices auto-corrigés (2/2)

Exercice 3 — Bootstrap apparié et décision

Écrivez ic_difference(ok_A, ok_B, B=2000, rng=None) renvoyant (écart moyen, borne basse, borne haute) par bootstrap apparié percentile, et decision(ic, seuil_min) renvoyant "adopter" si la borne basse dépasse seuil_min, "rejeter" si la borne haute est < 0, "indécis" sinon.

Correction

def ic_difference(ok_A, ok_B, B=2000, rng=None):
    rng = rng or np.random.default_rng(0); a, b = np.asarray(ok_A, float), np.asarray(ok_B, float); n = len(a)
    idx = rng.integers(n, size=(B, n)); d = b[idx].mean(1) - a[idx].mean(1)
    return float(b.mean() - a.mean()), float(np.percentile(d, 2.5)), float(np.percentile(d, 97.5))
def decision(ic, seuil_min=0.0):
    m, lo, hi = ic
    if lo > seuil_min: return "adopter"
    if hi < 0: return "rejeter"
    return "indécis"

Exercice 4 — Elo et Bradley-Terry sur des comparaisons

Implémentez elo(comparaisons, K=32) (séquentiel, départ 1000) et bradley_terry(comparaisons, n, iters) (gradient sur la log-vraisemblance, forces centrées). Vérifiez que les deux retrouvent l’ordre vrai sur 2 000 comparaisons simulées, et que BT est indépendant de l’ordre des comparaisons alors qu’Elo ne l’est pas.

Correction

def elo(comparaisons, n, K=32):
    R = np.full(n, 1000.0)
    for i, j, w in comparaisons:
        Ei = 1 / (1 + 10 ** ((R[j] - R[i]) / 400)); Si = 1.0 if w == i else 0.0
        R[i] += K * (Si - Ei); R[j] += K * ((1 - Si) - (1 - Ei))
    return R
def bradley_terry(comparaisons, n, iters=300, lr=2.0):
    r = np.zeros(n); I = np.array([c[0] for c in comparaisons]); J = np.array([c[1] for c in comparaisons]); W = np.array([1.0 if c[2] == c[0] else 0.0 for c in comparaisons])
    for _ in range(iters):
        p = 1 / (1 + np.exp(-(r[I] - r[J]))); g = np.zeros(n); np.add.at(g, I, W - p); np.add.at(g, J, -(W - p))
        r += lr * g / len(comparaisons); r -= r.mean()             # gradient MOYEN de la log-vraisemblance : stable quel que soit le nombre de comparaisons
    return r

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Un modèle de détection de fraude annonce : exactitude 99,2 %, ROC-AUC 0,97. Le métier dit qu’il « ne sert à rien ». Que s’est-il passé ? Quelles métriques auraient dû être rapportées ?

Correction. Prévalence probable ≈ 0,5 % : prédire « pas de fraude » donne déjà 99,5 % d’exactitude — le modèle fait moins bien que le trivial. Une ROC-AUC de 0,97 signifie qu’un fraudeur a un score supérieur à un honnête dans 97 % des paires ; mais avec 200 honnêtes pour 1 fraudeur, un FPR de 5 % produit 10 fausses alertes par vraie fraude : précision ≈ 9 % au point de fonctionnement. Rapporter : la courbe précision-rappel et l’AP (baseline = prévalence 0,005), la précision au rappel exigé (ou le rappel à la précision que les analystes peuvent traiter : 100 alertes/jour), le coût total (fraudes ratées × montant + alertes × coût de traitement), par segment (montants, canaux), et la calibration si les scores servent à prioriser.

Exercice 2. Deux systèmes de traduction : A obtient BLEU 34,1, B 33,2 sur le même jeu. Le client préfère B dans 70 % des cas en aveugle. Expliquer, et dire ce qu’il faut faire.

Correction. BLEU mesure le recouvrement de n-grammes avec une référence unique (Théorème 6) : A est peut-être plus « littéral », B plus fluide et reformulé — pénalisé par BLEU, préféré par les humains. Un écart de 0,9 BLEU n’est de toute façon pas significatif sans bootstrap apparié sur les phrases (IC typique ± 1). À faire : (1) juger 300 phrases par 2 traducteurs (kappa), avec critères (adéquation, fluidité), (2) métriques apprises corrélées aux humains (COMET, BERTScore) et chrF, (3) analyse d’erreurs par type (omissions, contresens — graves ; style — mineur), (4) métrique extrinsèque : temps de post-édition. Le BLEU reste utile en suivi de régression du même système, pas pour départager deux systèmes proches.

Exercice 3. Concevoir l’évaluation d’un assistant RAG interne avant déploiement : lister les jeux de données, les métriques, les seuils, et les décisions associées.

Correction. Jeux : 300 questions représentatives (logs anonymisés + rédaction) annotées avec passages pertinents et réponse de référence ; 60 questions hors périmètre (refus attendu) ; 40 cas adverses (injection, données sensibles) ; 100 questions d’un domaine voisin (robustesse). Recherche : R@5 ≥ 0,85, nDCG@5 rapporté, latence p95 < 300 ms. Génération : fidélité ≥ 0,9 (LLM-juge validé sur 100 cas humains, κ ≥ 0,6), exactitude ≥ 0,75 (IC bootstrap), citations valides ≥ 0,95, refus corrects ≥ 0,9 avec sur-refus ≤ 0,05 sur les questions légitimes. Sécurité : 0 fuite, taux de compromission ≤ 2 % sur les cas adverses. Coût/latence : p95 < 6 s, coût/requête ≤ budget. Décision : déployer en bêta si tous les seuils sont atteints ; sinon, le composant en défaut (Théorème 3 de L26 pour arbitrer recherche vs génération) ; en production, suivre les mêmes métriques sur un échantillon hebdomadaire jugé par humains + télémétrie (escalades, reformulations), et re-tester à chaque changement de modèle, de prompt ou de corpus (L35).

Vérification

Détection d’un événement rare (0,5 %) : ROC-AUC 0,96. Peut-on conclure que le détecteur est utilisable ?

Deux questions supplémentaires

1. Pourquoi le log-loss est-il une règle de score propre et pas l’exactitude ? Son espérance est minimale quand on annonce la vraie probabilité (Théorème 3) ; l’exactitude ne distingue pas 0,51 de 0,99.

2. Pourquoi apparier les rééchantillonnages bootstrap quand on compare deux systèmes ? Les cas sont partagés : la variance de la différence est réduite ; l’IC non apparié est trop large et masque des différences réelles.

Référence

Les mots à retenir

Mot	Définition
Règle de score propre	Incite à annoncer ses vraies probabilités (log-loss, Brier).
AUC	P(score positif > score négatif) ; invariante à l’ordre et à la prévalence.
Calibration / ECE / Brier	Accord entre confiance et fréquence ; fiabilité − résolution + incertitude.
Macro / micro	Moyenne par classe / sur les comptes agrégés.
nDCG, MRR, R@k	Classement gradué / premier pertinent / couverture.
BLEU, chrF, BERTScore	Recouvrement lexical, caractères, sémantique.
pass@k	Probabilité qu’au moins un de k échantillons passe les tests ; estimateur sans biais.
Contamination	Données de test dans le pré-entraînement ; tester sur du privé/reformulé.
Kappa / Bradley-Terry	Accord corrigé du hasard / forces à partir de comparaisons.
Bootstrap apparié, McNemar	IC et test pour deux systèmes sur les mêmes cas.
Goodhart	Une métrique optimisée cesse de mesurer.

Suite

Vous savez juger. Voyons sur quoi tout cela tourne.

Chapitre suivant : les infrastructures de l’IA — GPU, mémoire, réseau, stockage, parallélismes, serveurs d’inférence, cloud vs local, et leurs coûts.

← L31 Sommaire L33 : infrastructures →