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

Maintenir un modèle : le monde change, le modèle non.

Un modèle déployé est une photographie du passé. Les données dérivent (nouveaux capteurs, nouveaux clients, nouvelles formulations), les relations changent (dérive de concept), les dépendances évoluent (API, bibliothèques, modèles amont), et personne ne remarque tant que quelqu’un ne mesure pas. Ce chapitre couvre la détection de dérive (tests statistiques, distances entre distributions, monitoring sans étiquettes), le monitoring de qualité (étiquettes différées, échantillonnage, LLM-juge en production), le ré-entraînement (quand, comment, avec quelles données), le versionnage, les retours utilisateurs, la gestion des incidents et les coûts — avec la théorie et les articles.

Durée : 3 séances · Prérequis : L11, L32, L33, L34. Objectifs : implémenter des détecteurs de dérive (KS, PSI, KL/JS, MMD, classifieur adversarial) ; concevoir un tableau de bord de production ; définir une politique de ré-entraînement ; gérer les versions et les retours arrière ; rédiger un post-mortem.

Ce que vous saurez faire à la fin

Distinguer dérive de covariables, de concept, de prior, et les détecter avec ou sans étiquettes.
Fixer des seuils d’alerte fondés sur des tests et un taux de fausses alertes contrôlé.
Décider entre ré-entraîner, réajuster un seuil, recalibrer ou revenir en arrière.
Outiller : versions de modèle/données/prompt, déploiement progressif, journalisation, boucle de retours.

Fiche de cours · Définitions

Définitions

Définition (dérives). Soit p(x, y) = p(x)p(y | x). Dérive de covariables : p(x) change, p(y | x) stable (nouveaux types d’entrées). Dérive de concept : p(y | x) change (la même entrée mérite une autre sortie : changement de règle, de comportement). Dérive de prior : p(y) change (proportion des classes). Dérive de prédiction : la distribution des sorties du modèle change (symptôme observable sans étiquettes).

Définition (étiquettes différées, proxy). En production, la vérité (y) arrive souvent en retard (fraude confirmée un mois plus tard) ou jamais. On surveille des proxys : distribution des entrées, des prédictions, des confiances, des retours utilisateurs, des taux d’escalade, du temps de traitement.

Définition (test de dérive). Test statistique entre une fenêtre de référence (données d’entraînement ou période stable) et une fenêtre courante : Kolmogorov-Smirnov (1D continu), χ² (catégoriel), PSI (population stability index), divergence KL/JS, distance de Wasserstein, MMD (noyaux, multidimensionnel), classifieur adversarial (un modèle qui distingue les deux fenêtres : son AUC mesure la dérive).

Définition (monitoring). Collecte, agrégation et visualisation de métriques système (latence, erreurs, coût), données (dérive, valeurs manquantes, schémas) et modèle (qualité sur étiquettes disponibles, calibration, tranches), avec alertes à seuils et runbooks.

Définition (ré-entraînement). Périodique (chaque semaine), déclenché (dérive détectée, qualité sous seuil), ou continu (apprentissage en ligne) ; sur fenêtre glissante, cumulatif, ou pondéré par récence ; toujours suivi de l’évaluation complète (L32) et d’un déploiement progressif.

Définition (versionnage et déploiement). Version = (code, données, hyperparamètres, poids, prompt, dépendances) hachés et liés. Déploiement shadow (le nouveau modèle prédit sans agir), canary (1–5 % du trafic), A/B (comparaison mesurée), retour arrière (rollback) en un geste.

Définition (boucle de retour, feedback loop). Les prédictions influencent les données futures (un système de recommandation façonne les clics ; un détecteur de fraude change le comportement des fraudeurs) : l’évaluation naïve est biaisée ; il faut des données de contrôle (trafic non traité ou aléatoire).

Définition (incident, post-mortem). Dégradation ou comportement dangereux en production. Post-mortem sans blâme : chronologie, cause racine, impact, ce qui a détecté (ou pas), actions.

Fiche de cours · Formules

Formules à connaître

Kolmogorov-Smirnov : D = sup_x |F_réf(x) − F_cour(x)| ; seuil à 5 % ≈ 1,36·√((n + m)/(nm))

PSI = Σ_bins (p_cour − p_réf)·ln(p_cour/p_réf) ; repères : < 0,1 stable, 0,1–0,25 à surveiller, > 0,25 dérive (PSI = KL symétrisée sur bins)

KL(p ‖ q) = Σ p log(p/q) (asymétrique, infinie si q = 0 où p > 0) ; JS = ½KL(p ‖ m) + ½KL(q ‖ m), m = (p + q)/2, bornée par ln 2

Wasserstein-1 (1D) : W₁ = ∫ |F_réf(x) − F_cour(x)| dx — en unités de x, sensible aux déplacements, pas aux bins

MMD² = E[k(x, x′)] + E[k(y, y′)] − 2E[k(x, y)] avec un noyau k (gaussien) ; nul ssi les distributions sont égales (noyau caractéristique)

Classifieur adversarial : AUC ≈ 0,5 ⇒ pas de dérive détectable ; AUC → 1 ⇒ fenêtres séparables ; les variables importantes du classifieur localisent la dérive

χ² d’homogénéité (catégoriel) : Σ (O − E)²/E, ddl = (k − 1) ; attention : avec n grand, tout est « significatif » — regarder la taille d’effet (V de Cramér)

Taux de fausses alertes : avec m tests par jour au seuil α, ≈ mα alertes/jour sans dérive ⇒ Bonferroni ou seuils sur la taille d’effet

Estimation de la qualité sans étiquettes (sous dérive de covariables seule) : exactitude ≈ moyenne des confiances calibrées (ATC, DoC) ; invalide sous dérive de concept

Pondération par importance : w(x) = p_cour(x)/p_réf(x) ; risque courant ≈ Σ w(x_i)ℓ_i/Σ w(x_i) sur le jeu de référence étiqueté

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

Démonstrations à savoir refaire

Théorème 1 (sous dérive de covariables, le risque se corrige par pondération d’importance). Si p_cour(y | x) = p_réf(y | x) et que le support de p_cour est inclus dans celui de p_réf, alors E_cour[ℓ(h(x), y)] = E_réf[w(x)·ℓ(h(x), y)] avec w = p_cour(x)/p_réf(x).

E_cour[ℓ] = ∫∫ ℓ(h(x), y) p_cour(x) p(y | x) dx dy = ∫∫ ℓ(h(x), y) [p_cour(x)/p_réf(x)] p_réf(x) p(y | x) dx dy = E_réf[w(x)ℓ]. On peut donc estimer la qualité courante à partir du jeu de référence étiqueté et d’une estimation de w (par un classifieur réf/cour : w(x) = P(cour | x)/P(réf | x) × n_réf/n_cour). Limites : variance explosive si w prend de grandes valeurs (régions nouvelles), et faux dès que p(y | x) change (dérive de concept) — que rien ne peut détecter sans étiquettes.

Théorème 2 (la dérive de concept est indétectable sans étiquettes). Il existe deux situations, l’une sans dérive et l’autre avec dérive de concept, produisant exactement la même distribution des entrées et des prédictions.

Prenons p(x) inchangé et un modèle h fixé ; les prédictions h(x) ont donc la même distribution dans les deux cas. Situation 1 : p(y | x) inchangé. Situation 2 : p(y | x) modifié (par exemple, étiquettes inversées sur une région). Toute statistique calculée sur (x, h(x)) est identique ; seule l’observation de y (ou d’un proxy corrélé à y : retours utilisateurs, escalades) sépare les deux. Conséquence pratique : le monitoring sans étiquettes détecte les dérives de covariables et de prédiction ; pour le concept, il faut organiser l’arrivée d’étiquettes — échantillonnage aléatoire annoté chaque semaine, boucle de retour, LLM-juge validé — et surveiller les proxys métier.

Théorème 3 (taille d’effet vs significativité dans les tests de dérive). Pour un test de KS avec n = m échantillons, le seuil de détection est D* ≈ 1,36√(2/n) ; pour n = 10⁶, D* ≈ 0,002 : une dérive infime est « significative ». Le seuil d’alerte doit porter sur une taille d’effet (D, PSI, W₁) choisie pour son impact, pas sur la p-valeur.

Le seuil de KS décroît en 1/√n (statistique de Kolmogorov). À grande échelle, la p-valeur tend vers 0 pour tout écart non nul — or les distributions de production ne sont jamais exactement égales à la référence (saisonnalité, mélange). La question utile est « l’écart est-il assez grand pour dégrader le modèle ? » : calibrer le seuil de taille d’effet sur l’historique (relation observée entre PSI et perte de qualité quand des étiquettes étaient disponibles), et contrôler le taux de fausses alertes par variable (Bonferroni sur m variables, ou fenêtres plus longues).

Théorème 4 (une boucle de retour biaise l’évaluation). Si les données étiquetées observées sont celles que le modèle a sélectionnées (crédit accordé, contenu montré), la métrique estimée sur ces données n’est pas celle sur la population : l’estimateur est biaisé par la sélection, et le biais ne se réduit pas avec n.

Observé = {(x, y) : h(x) = 1}. E[ℓ | h(x) = 1] ≠ E[ℓ] en général : on ne voit jamais les faux négatifs (crédit refusé qui aurait remboursé). Plus de données de la même sélection n’aident pas (biais, pas variance). Remède : une fraction aléatoire non filtrée (exploration, ε %), ou une pondération inverse de la probabilité de sélection (IPW) quand celle-ci est connue (politique stochastique) ; c’est le problème des bandits/contrefactuels (L16).

01 / Détecter

Détecteurs de dérive implémentés : KS, PSI, JS, Wasserstein, MMD, classifieur

import numpy as np
rng = np.random.default_rng(0)
ref = rng.normal(0, 1, (4000, 3)); ref[:, 2] = rng.exponential(1, 4000)                       # référence : 3 variables
def fenetre(shift_mu=0.0, shift_scale=1.0, mix=0.0):
    x = rng.normal(shift_mu, shift_scale, (2000, 3)); x[:, 2] = rng.exponential(1 + shift_mu, 2000)
    if mix > 0: x[: int(mix * 2000), 0] += 4                                                # apparition d'un nouveau sous-groupe
    return x
def ks(a, b):
    v = np.sort(np.concatenate([a, b])); Fa = np.searchsorted(np.sort(a), v, "right") / len(a); Fb = np.searchsorted(np.sort(b), v, "right") / len(b)
    return np.abs(Fa - Fb).max(), 1.36 * np.sqrt((len(a) + len(b)) / (len(a) * len(b)))
def psi(a, b, bins=10):
    edges = np.quantile(a, np.linspace(0, 1, bins + 1)); edges[0], edges[-1] = -np.inf, np.inf
    pa = np.histogram(a, edges)[0] / len(a) + 1e-6; pb = np.histogram(b, edges)[0] / len(b) + 1e-6; return np.sum((pb - pa) * np.log(pb / pa))
def js(a, b, bins=30):
    lo, hi = min(a.min(), b.min()), max(a.max(), b.max()); pa = np.histogram(a, bins, (lo, hi))[0] / len(a) + 1e-9; pb = np.histogram(b, bins, (lo, hi))[0] / len(b) + 1e-9; m = (pa + pb) / 2
    return 0.5 * np.sum(pa * np.log(pa / m)) + 0.5 * np.sum(pb * np.log(pb / m))
def wasserstein1(a, b): q = np.linspace(0, 1, 500); return np.mean(np.abs(np.quantile(a, q) - np.quantile(b, q)))
def mmd2(X, Y, gamma=0.5):
    def k(A, B): d = ((A[:, None, :] - B[None, :, :]) ** 2).sum(-1); return np.exp(-gamma * d)
    return k(X, X).mean() + k(Y, Y).mean() - 2 * k(X, Y).mean()
def auc_adversarial(X, Y):                                                                       # régression logistique réf(0) vs cour(1)
    Z = np.vstack([X, Y]); t = np.r_[np.zeros(len(X)), np.ones(len(Y))]; Z = (Z - Z.mean(0)) / Z.std(0); w = np.zeros(Z.shape[1]); b = 0.0
    for _ in range(300): p = 1 / (1 + np.exp(-(Z @ w + b))); g = Z.T @ (p - t) / len(t); w -= 0.5 * g; b -= 0.5 * (p - t).mean()
    s = Z @ w + b; o = np.argsort(s); r = np.empty(len(s)); r[o] = np.arange(1, len(s) + 1); n1 = t.sum(); return (r[t == 1].sum() - n1 * (n1 + 1) / 2) / (n1 * (len(t) - n1)), w
scenarios = {"pas de dérive": fenetre(), "léger décalage (+0,15 σ)": fenetre(0.15), "variance ×1,5": fenetre(0, 1.5), "nouveau sous-groupe (10 %)": fenetre(mix=0.1), "fort décalage (+1 σ)": fenetre(1.0)}
print(f"{'scénario':28s} {'KS (seuil)':>13s} {'PSI':>6s} {'JS':>6s} {'W1':>6s} {'MMD²':>7s} {'AUC adv.':>9s}")
for nom, cur in scenarios.items():
    d, seuil = ks(ref[:, 0], cur[:, 0]); a, w = auc_adversarial(ref[:800], cur[:800])
    print(f"{nom:28s} {d:5.3f} ({seuil:.3f}) {psi(ref[:, 0], cur[:, 0]):6.3f} {js(ref[:, 0], cur[:, 0]):6.3f} {wasserstein1(ref[:, 0], cur[:, 0]):6.3f} {mmd2(ref[:300], cur[:300]):7.4f} {a:9.3f}")
print("\nLecture : KS/PSI/JS/W1 par variable (1D) ; MMD et AUC adversarial sur toutes les variables à la fois — l'AUC est la plus lisible (0,5 = rien ; 0,7 = net) et ses poids disent QUELLE variable dérive.")

01 / Détecter

Seuils, fausses alertes, fenêtres : régler un détecteur comme un test

import numpy as np
rng = np.random.default_rng(1)
# Sans dérive : combien d'alertes par jour avec 20 variables testées par KS à α = 5 % ? Puis avec Bonferroni, puis avec un seuil de TAILLE D'EFFET.
def ks_stat(a, b):
    v = np.sort(np.concatenate([a, b])); Fa = np.searchsorted(np.sort(a), v, "right") / len(a); Fb = np.searchsorted(np.sort(b), v, "right") / len(b); return np.abs(Fa - Fb).max()
n_ref, n_cur, m_vars, jours = 5000, 2000, 20, 60
seuil_5 = 1.36 * np.sqrt((n_ref + n_cur) / (n_ref * n_cur)); seuil_bonf = 1.36 * np.sqrt(-np.log(0.05 / m_vars / 2) / 2 * (n_ref + n_cur) / (n_ref * n_cur))
alertes = {"α = 5 % par variable": 0, "Bonferroni (α/20)": 0, "taille d'effet D > 0,05": 0}
for j in range(jours):
    for v in range(m_vars):
        d = ks_stat(rng.normal(0, 1, n_ref), rng.normal(0, 1, n_cur))
        alertes["α = 5 % par variable"] += d > seuil_5; alertes["Bonferroni (α/20)"] += d > seuil_bonf; alertes["taille d'effet D > 0,05"] += d > 0.05
for k, v in alertes.items(): print(f"{k:26s} : {v / jours:.2f} fausses alertes/jour sans aucune dérive")
# Puissance : une dérive réelle de +0,1 σ sur une variable est-elle détectée par le seuil d'effet ? Dépend de la taille de fenêtre.
for n_cur in (200, 1000, 5000):
    det = np.mean([ks_stat(rng.normal(0, 1, n_ref), rng.normal(0.1, 1, n_cur)) > 0.05 for _ in range(100)])
    print(f"fenêtre courante de {n_cur:5d} : dérive de +0,1 σ détectée (D > 0,05) dans {det:.0%} des cas")
print("\nRègle : choisir le seuil d'effet d'après l'impact historique sur la qualité, la fenêtre pour la puissance voulue, et accepter ≈ 1 fausse alerte/mois — pas 20/jour (fatigue d'alerte = alertes ignorées).")

02 / Surveiller la qualité

Qualité sans étiquettes, avec étiquettes différées, et par pondération d’importance

import numpy as np
rng = np.random.default_rng(2)
# Modèle : régression logistique sur 2 variables ; vérité y ~ Bernoulli(σ(2x1 − x2))
def verite(X): return (rng.random(len(X)) < 1 / (1 + np.exp(-(2 * X[:, 0] - X[:, 1])))).astype(int)
def modele(X): return 1 / (1 + np.exp(-(1.8 * X[:, 0] - 0.9 * X[:, 1])))                              # modèle imparfait mais calibré sur la référence
Xref = rng.normal(0, 1, (5000, 2)); yref = verite(Xref); pref = modele(Xref)
print(f"référence : exactitude {np.mean((pref > 0.5) == yref):.3f}, confiance moyenne {np.mean(np.maximum(pref, 1 - pref)):.3f} (≈ exactitude : modèle calibré)")
# 1) Dérive de covariables : x1 se déplace de +0,8 ; p(y|x) inchangé → la confiance moyenne suit encore l'exactitude (ATC/DoC) ; la pondération d'importance (Théorème 1) aussi
Xc = rng.normal(0, 1, (5000, 2)); Xc[:, 0] += 0.8; yc = verite(Xc); pc = modele(Xc)
w = np.exp(0.8 * Xref[:, 0] - 0.32)                                                              # ratio de densités exact : N(0,8;1)/N(0;1) sur x1
acc_iw = np.sum(w * ((pref > 0.5) == yref)) / w.sum()
print(f"covariables : vraie exactitude {np.mean((pc > 0.5) == yc):.3f} | estimée par confiance {np.mean(np.maximum(pc, 1 - pc)):.3f} | par pondération d'importance {acc_iw:.3f}")
# 2) Dérive de concept : la relation change (y ~ σ(2x1 + x2)) ; entrées et prédictions IDENTIQUES → rien ne bouge sans étiquettes (Théorème 2)
Xk = rng.normal(0, 1, (5000, 2)); yk = (rng.random(5000) < 1 / (1 + np.exp(-(2 * Xk[:, 0] + Xk[:, 1])))).astype(int); pk = modele(Xk)
print(f"concept     : vraie exactitude {np.mean((pk > 0.5) == yk):.3f} | estimée par confiance {np.mean(np.maximum(pk, 1 - pk)):.3f} ← FAUX, et aucun détecteur sur x ou p ne peut le voir")
# 3) Étiquettes différées : annoter 200 cas aléatoires par semaine suffit pour un IC utile
for n in (50, 200, 800): print(f"{n:4d} étiquettes/semaine → IC à 95 % de l'exactitude ≈ ± {1.96 * np.sqrt(0.8 * 0.2 / n):.3f}")
print("→ Budget minimal de maintenance : un échantillon aléatoire annoté chaque semaine (ou un LLM-juge validé), sinon la dérive de concept est invisible jusqu'à la plainte.")

03 / Agir

Politique de ré-entraînement : quand, sur quoi, comment valider — et les alternatives

Signal	Diagnostic probable	Action	Coût / risque
Dérive de prédiction (plus de classe A), entrées stables	Bug amont (schéma, unité, encodage), changement de prétraitement	Vérifier le pipeline avant tout ré-entraînement ; rollback si régression	Faible ; le ré-entraînement « guérirait » le symptôme en apprenant le bug
Dérive de covariables, qualité stable sur l’échantillon annoté	Nouveaux cas couverts	Surveiller ; enrichir le jeu de test avec les nouveaux cas	Aucun
Dérive de covariables + baisse de qualité	Régions nouvelles mal couvertes	Ré-entraîner avec données récentes (fenêtre glissante ou pondérée) ; augmentation	Modéré ; valider par tranche
Dérive de prior (proportion des classes)	Saisonnalité, campagne	Réajuster le seuil de décision ou les a priori (correction bayésienne) sans ré-entraîner	Faible
Calibration dégradée, ordre correct	Confiances décalées	Recalibrer (température, Platt) sur l’échantillon récent	Faible
Dérive de concept confirmée par étiquettes	La règle du monde a changé	Ré-entraîner sur données récentes étiquetées ; revoir les variables ; parfois refaire le modèle	Élevé ; risque d’oubli des cas anciens (garder un mélange)
Qualité stable, coût/latence en hausse	Volume, longueur des entrées	Optimisation infra (L33), distillation, cache	Modéré
Changement de version d’un modèle amont (API, embeddings)	Rupture silencieuse	Banc d’essai automatique à chaque version ; ré-indexer si les embeddings changent (RAG)	Variable ; figer les versions

04 / Outiller

Versionnage, déploiement progressif, retour arrière, journalisation

Pratique	Contenu	Outils	Règle
Version de modèle	Hash du code (commit), des données (DVC), des hyperparamètres, des poids, du prompt, de l’environnement (lockfile), du tokeniseur	MLflow/W&B + registre, DVC, Git, conteneur	Toute prédiction en production est traçable à une version complète
Journalisation des prédictions	Entrée (ou son hash/plongement), sortie, confiance, version, latence, horodatage, identifiant de session ; échantillon des entrées brutes (avec consentement/anonymisation)	Base événementielle, stockage objet, Langfuse/Arize pour LLM	Sans journal, pas de post-mortem ni de ré-entraînement
Déploiement shadow	Le candidat prédit en parallèle sans agir ; on compare hors ligne	Routage applicatif	Avant tout canary sur un modèle critique
Canary / A/B	1 → 5 → 25 → 100 % ; métriques métier et techniques comparées avec IC (L32)	Feature flags, service mesh, KServe	Critère d’arrêt automatique (p95, erreurs, qualité proxy)
Retour arrière	Version précédente prête, données compatibles, prompts et index associés	Registre + déploiement immuable	Testé régulièrement (comme une sauvegarde)
Tests de non-régression	Banc d’essai (L32) exécuté en CI à chaque changement de modèle, prompt, index, dépendance	CI/CD, pytest	Une régression bloque le déploiement
Runbooks et alertes	Pour chaque alerte : quoi vérifier, qui appeler, comment revenir en arrière	Grafana/Prometheus, PagerDuty	Une alerte sans runbook est du bruit
Boucle de retours	Bouton « réponse utile ? », corrections des opérateurs, escalades → file d’annotation → jeu de test enrichi	Outil d’annotation (Label Studio, Argilla)	Fermer la boucle : chaque incident devient un cas de test

05 / Incidents

Post-mortem d’un incident IA : modèle et exemple

POST-MORTEM #23 — Assistant support : réponses erronées sur les procédures de sécurité (2026-08-12 → 08-19)

Impact : 7 jours ; ~340 réponses citant une version obsolète de la procédure P-17 (révisée le 08-11) ; 2 escalades ; 0 accident.
Détection : plainte d'un technicien (08-19). Le monitoring n'a rien signalé : entrées et sorties stables, fidélité 0,92 (le modèle citait
  fidèlement… un document périmé), pas d'étiquettes sur ces questions dans l'échantillon hebdomadaire (0 sur 200).
Chronologie : 08-11 nouvelle P-17 publiée dans la GED ; l'ingestion nocturne a échoué (format PDF/A non géré) ; l'erreur est allée dans un
  journal non surveillé ; l'index a gardé l'ancienne version ; 08-19 plainte ; 08-19 14:00 ré-indexation manuelle ; 08-20 correctif du parseur.
Cause racine : pipeline d'ingestion sans alerte sur échec ni contrôle de fraîcheur ; métadonnée « version du document » absente du contexte.
Facteurs contributifs : la fidélité (L26) mesure la cohérence avec le contexte, pas l'actualité du contexte ; l'échantillon annoté
  hebdomadaire ne stratifie pas par document ; aucune règle « documents de sécurité = priorité ».
Ce qui a bien marché : rollback inutile (correction par ré-indexation en 1 h) ; les citations ont permis de retrouver les 340 réponses.
Actions : (1) alerte sur échec d'ingestion + contrôle de fraîcheur (âge max de l'index par collection) — fait ; (2) métadonnée de version
  et date dans chaque extrait, et consigne de privilégier la plus récente — fait ; (3) stratifier l'échantillon annoté par criticité — en cours ;
  (4) test de non-régression : « question sur P-17 → cite la version du jour » — fait ; (5) rappel aux utilisateurs des 340 réponses — fait.
Sans blâme : le parseur a été écrit pour les formats vus en 2025 ; le problème est l'absence de filet, pas l'erreur.

Un post-mortem se lit en 3 minutes et produit des actions vérifiables. Les incidents IA typiques : données périmées, changement silencieux amont, dérive de concept non étiquetée, seuil non réajusté, boucle de retour (le modèle apprend ses propres sorties), injection, coût qui dérive.

06 / Articles

Les articles à lire

Article	Contribution	À retenir
Sculley et al., Hidden Technical Debt in Machine Learning Systems, NeurIPS 2015	Dettes : enchevêtrement, boucles de retour, dépendances de données, glue code	« Changer quoi que ce soit change tout » (CACE)
Gama et al., A Survey on Concept Drift Adaptation, ACM CSUR 2014	Taxonomie des dérives et des détecteurs	Soudaine, graduelle, incrémentale, récurrente
Rabanser, Günnemann & Lipton, Failing Loudly: An Empirical Study of Methods for Detecting Dataset Shift, NeurIPS 2019 — 1810.11953	Comparaison des détecteurs ; réduction de dimension + tests	Le classifieur adversarial et les tests sur les sorties du modèle marchent bien
Lipton, Wang & Smola, Detecting and Correcting for Label Shift with Black Box Predictors, ICML 2018 — 1802.03916	Dérive de prior : estimation et correction via la matrice de confusion	Correction sans ré-entraînement
Saerens, Latinne & Decaestecker, Adjusting the Outputs of a Classifier to New a Priori Probabilities, Neural Computation 2002	EM pour estimer la prévalence	Le code de la partie 03
Sugiyama et al., Covariate Shift Adaptation by Importance Weighted Cross Validation, JMLR 2007	Pondération d’importance	Théorème 1 et sa variance
Garg et al., Leveraging Unlabeled Data to Predict Out-of-Distribution Performance (ATC), ICLR 2022 — 2201.04234	Estimer l’exactitude sans étiquettes par un seuil de confiance	Valide sous covariables, pas sous concept (Théorème 2)
Breck et al., The ML Test Score: A Rubric for ML Production Readiness, IEEE Big Data 2017	28 tests pour données, modèle, infra, monitoring	Une liste de contrôle concrète
Shankar et al., Operationalizing Machine Learning: An Interview Study, 2022 — 2209.09125	Ce que font vraiment les ingénieurs MLOps	Vitesse, validation, versionnage ; la plupart des incidents viennent des données
Chen et al., How Is ChatGPT’s Behavior Changing over Time?, 2023 — 2307.09009	Dérive des API de LLM entre versions	Banc d’essai à chaque version amont
Google SRE Book (chap. incidents, post-mortems) ; Allspaw, Blameless PostMortems	Culture de l’incident	Sans blâme, avec actions

TP guidé

TP — Un modèle en production simulée pendant « 12 semaines » (5 h)

Système. Un classifieur (L13/L31) ou votre RAG, avec journalisation des prédictions (SQLite ou Parquet : entrée, sortie, confiance, version, horodatage).
Simulateur de production. Générer 12 semaines de trafic avec des dérives programmées : semaine 4 décalage de covariables, semaine 7 changement de prior, semaine 9 dérive de concept, semaine 11 bug amont (colonne en mauvaise unité). Étiquettes disponibles pour 200 cas aléatoires par semaine.
Détecteurs. Implémenter (ou utiliser Evidently/Alibi Detect) KS/PSI par variable, AUC adversarial, dérive des prédictions, qualité sur l’échantillon, calibration. Tableau de bord hebdomadaire ; seuils réglés sur les 3 premières semaines (fausses alertes ≤ 1/mois).
Politique. Écrire la règle de décision (tableau 03) ; l’appliquer chaque semaine : rien / recalibrer / réajuster le seuil / ré-entraîner (fenêtre glissante de 6 semaines) / rollback ; valider chaque changement par le banc d’essai et un canary simulé (50 % du trafic).
Bilan. Quelles dérives ont été détectées, quand, avec quel délai ? Laquelle ne l’a pas été (concept sans étiquettes ?) ; coût total (annotations, ré-entraînements) ; un post-mortem pour le bug amont.
Livrable. Dépôt (simulateur, détecteurs, tableau de bord), journal des décisions hebdomadaires, post-mortem, et une page « ce que je surveillerais en vrai ».

Exercices

Exercices auto-corrigés

Exercice 1 — PSI et ses propriétés

Implémentez psi(ref, cur, bins) avec des bins définis par les quantiles de la référence (bornes ±∞), et vérifiez : PSI ≈ 0 pour deux échantillons de la même loi ; PSI croît avec le décalage ; PSI est invariant par transformation monotone croissante (appliquée aux deux) ; PSI(ref, cur) ≠ PSI(cur, ref) en général mais les deux sont ≥ 0.

Correction

def psi(ref, cur, bins=10):
    edges = np.quantile(ref, np.linspace(0, 1, bins + 1)); edges[0], edges[-1] = -np.inf, np.inf
    pr = np.histogram(ref, edges)[0] / len(ref) + 1e-6; pc = np.histogram(cur, edges)[0] / len(cur) + 1e-6
    return float(np.sum((pc - pr) * np.log(pc / pr)))

Exercice 2 — Pondération d’importance (Théorème 1)

Écrivez poids_importance(Xref, Xcur) qui estime w(x) = p_cur(x)/p_ref(x) par un classifieur logistique réf/cour (avec correction des effectifs), puis exactitude_ponderee(pred_ok_ref, w). Vérifiez sur une dérive de covariables 1D que l’estimation approche la vraie exactitude courante à ±0,03.

Correction

def poids_importance(Xref, Xcur, iters=500, lr=0.5):
    Z = np.vstack([Xref, Xcur]); t = np.r_[np.zeros(len(Xref)), np.ones(len(Xcur))]; mu, sd = Z.mean(0), Z.std(0); Zs = (Z - mu) / sd
    w = np.zeros(Z.shape[1]); b = 0.0
    for _ in range(iters):
        p = 1 / (1 + np.exp(-(Zs @ w + b))); w -= lr * Zs.T @ (p - t) / len(t); b -= lr * (p - t).mean()
    p_ref = 1 / (1 + np.exp(-(((Xref - mu) / sd) @ w + b)))
    return p_ref / (1 - p_ref) * len(Xref) / len(Xcur)
def exactitude_ponderee(ok_ref, w): return float(np.sum(w * ok_ref) / np.sum(w))

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Correction de dérive de prior et estimation EM

Implémentez corriger_prior(p, pi_ref, pi_cur) et estimer_prior(p, pi_ref, iters) (EM de Saerens : itérer π ← moyenne des probabilités corrigées). Vérifiez que la correction est l’identité si π ne change pas, qu’elle augmente les probabilités quand π augmente, et que l’EM retrouve une prévalence de 0,25 à ±0,02 à partir de scores calibrés pour π_ref = 0,5.

Correction

def corriger_prior(p, pi_ref, pi_cur):
    a = p * pi_cur / pi_ref; b = (1 - p) * (1 - pi_cur) / (1 - pi_ref); return a / (a + b)
def estimer_prior(p, pi_ref, iters=100):
    pi = pi_ref
    for _ in range(iters): pi = corriger_prior(p, pi_ref, pi).mean()
    return float(pi)

Exercice 4 — Politique d’alerte à taux de fausses alertes contrôlé

Écrivez seuil_effet(ref, n_cur, alpha_jour, m_vars, essais, rng) : par simulation sans dérive (rééchantillonner la référence), le seuil D de KS tel que la probabilité qu’au moins une des m_vars variables dépasse D en un jour soit ≈ alpha_jour. Puis puissance(ref, n_cur, D, decalage, essais, rng) : fraction de détections pour un décalage de moyenne donné.

Correction

def seuil_effet(ref, n_cur, alpha_jour=0.05, m_vars=10, essais=200, rng=None):
    rng = rng or np.random.default_rng(0)
    maxs = [max(ks_stat(ref, rng.choice(ref, n_cur)) for _ in range(m_vars)) for _ in range(essais)]
    return float(np.quantile(maxs, 1 - alpha_jour))
def puissance(ref, n_cur, D, decalage, essais=100, rng=None):
    rng = rng or np.random.default_rng(0)
    return float(np.mean([ks_stat(ref, rng.choice(ref, n_cur) + decalage) > D for _ in range(essais)]))

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Le monitoring d’un détecteur de défauts sur une ligne de production n’a déclenché aucune alerte en six mois ; le taux de défauts non détectés, mesuré par le contrôle final, a pourtant doublé. Expliquer et corriger.

Correction. Les entrées (images) et les prédictions étaient stables : ni dérive de covariables ni de prédiction détectable. Le doublement des ratés signale une dérive de concept (nouveaux types de défauts, ou changement de ce qui est considéré comme défaut) que le monitoring sans étiquettes ne peut voir (Théorème 2) — alors que des étiquettes existaient (le contrôle final !) mais n’étaient pas reliées au monitoring. Corrections : (1) brancher les étiquettes du contrôle final (même en retard) sur les prédictions journalisées (identifiant de pièce) : rappel hebdomadaire par type de défaut avec IC ; (2) alerte sur cette métrique ; (3) file d’annotation des faux négatifs → ré-entraînement mensuel sur fenêtre glissante + test de non-régression sur les anciens défauts ; (4) échantillon d’images de la nouvelle production annoté pour enrichir le jeu de test.

Exercice 2. Un système de recommandation est ré-entraîné chaque nuit sur les clics de la veille. Après trois mois, la diversité des recommandations s’est effondrée et les ventes baissent. Quel mécanisme ? Quelle correction ?

Correction. Boucle de retour (Théorème 4) : le modèle apprend sur les clics qu’il a lui-même provoqués ; les articles jamais montrés n’ont jamais de clics, donc jamais de score, donc ne sont jamais montrés — effondrement vers quelques items populaires (« rich get richer »). L’évaluation hors ligne sur les clics observés reste bonne (biais de sélection), ce qui masque le problème. Corrections : (1) trafic d’exploration (ε = 5 % de recommandations aléatoires ou par échantillonnage de Thompson) qui fournit des données non biaisées ; (2) journaliser la probabilité de présentation et pondérer par inverse de propension (IPW) à l’entraînement et à l’évaluation ; (3) métriques de diversité/couverture dans le tableau de bord avec alertes ; (4) contrainte de diversité dans le classement final ; (5) un A/B contre une version figée pour mesurer l’effet réel sur les ventes, pas sur les clics.

Exercice 3. Le fournisseur d’API d’embeddings de votre RAG annonce une nouvelle version « améliorée » et la dépréciation de l’ancienne dans 90 jours. Plan d’action.

Correction. Les nouveaux embeddings ne sont pas comparables aux anciens : requêtes et documents doivent être dans le même espace — mélanger les deux casse la recherche silencieusement. Plan : (1) figer la version actuelle jusqu’à la bascule ; (2) ré-indexer tout le corpus avec la nouvelle version dans un index parallèle (coût : n documents × prix par token, à chiffrer) ; (3) banc d’essai de recherche (R@k, nDCG, L26) sur les deux index : la « meilleure » version l’est-elle sur vos données ? ; (4) shadow puis canary sur la recherche ; (5) bascule atomique (requêtes et index ensemble), rollback préparé (ancien index conservé jusqu’à la dépréciation) ; (6) ADR mis à jour : envisager un modèle d’embeddings ouvert hébergé localement pour supprimer ce risque récurrent ; (7) ajouter au monitoring la version d’embeddings de chaque requête et de l’index (invariant : égales).

Vérification

Le monitoring de dérive des entrées et des prédictions est vert depuis six mois. Peut-on conclure que la qualité du modèle est stable ?

Deux questions supplémentaires

1. Pourquoi ne pas alerter sur la p-valeur d’un test de KS à grande échelle ? Elle tend vers 0 pour tout écart non nul ; alerter sur une taille d’effet calibrée sur l’impact (Théorème 3).

2. Que faire face à une dérive de prior seule ? Réajuster le seuil ou corriger les probabilités a posteriori, sans ré-entraîner.

Référence

Les mots à retenir

Mot	Définition
Dérive de covariables / concept / prior	p(x) / p(y \| x) / p(y) change.
KS, PSI, JS, W₁, MMD, AUC adversarial	Détecteurs 1D et multidimensionnels ; alerter sur la taille d’effet.
Étiquettes différées	Organiser leur arrivée : échantillon annoté, retours, juge.
Pondération d’importance	Corriger le risque sous dérive de covariables.
Correction de prior	Réajuster les probabilités sans ré-entraîner.
Shadow / canary / rollback	Déploiement progressif et retour arrière.
Boucle de retour	Le modèle façonne ses données ; exploration ou IPW.
Post-mortem	Chronologie, cause racine, détection, actions ; sans blâme.

Suite

Tout commence et finit par les données.

Chapitre suivant : créer un jeu de données from scratch — collecte, annotation, qualité, nettoyage, déduplication, fuites, biais, documentation, licences, et les mathématiques de l’annotation.

← L34 Sommaire L36 : données →