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

Les données : collecter, annoter, nettoyer, documenter — tout ce qu’il faut savoir.

Un modèle n’est jamais meilleur que ses données. Ce chapitre traite la création d’un jeu de données de bout en bout : définir ce qu’on mesure, collecter (sources, consentement, licences, échantillonnage), annoter (consignes, accord inter-annotateurs, annotation active et assistée), nettoyer (doublons, valeurs manquantes, aberrantes, étiquettes bruitées, fuites), équilibrer et augmenter, séparer (train/val/test sans fuite), documenter (datasheet), versionner — et les données pour LLM (déduplication à grande échelle, filtrage de qualité, données synthétiques, contamination). Avec les mathématiques (taille d’échantillon, accord, bruit d’étiquettes, déduplication par MinHash) et les articles.

Durée : 4 séances · Prérequis : L08, L11, L13, L32. Objectifs : concevoir une collecte et une consigne d’annotation ; mesurer et améliorer l’accord ; nettoyer et dédupliquer (exact et quasi-doublons) ; détecter les fuites et les biais ; séparer correctement ; documenter et versionner ; savoir quand générer des données synthétiques.

Ce que vous saurez faire à la fin

Calculer la taille d’échantillon nécessaire et le budget d’annotation.
Écrire une consigne d’annotation qui produit un kappa > 0,7, et itérer.
Implémenter la déduplication par MinHash/LSH et la détection d’étiquettes bruitées.
Produire un jeu versionné et documenté, avec une séparation sans fuite.

Fiche de cours · Définitions

Définitions

Définition (jeu de données). Ensemble d’exemples (x, y) avec métadonnées (source, date, annotateur, licence), une documentation (datasheet), un schéma (types, unités, valeurs autorisées), une version. Un jeu sans ces éléments est une collection de fichiers.

Définition (population, échantillon, biais d’échantillonnage). Population : ce sur quoi le modèle sera utilisé. Échantillon : ce qu’on collecte. Biais : l’échantillon ne représente pas la population (biais de sélection, de survie, de disponibilité, temporel). Un modèle apprend l’échantillon, pas la population.

Définition (annotation). Attribution d’étiquettes par des humains selon une consigne (guidelines). Qualité mesurée par l’accord inter-annotateurs (kappa, alpha) et contre un étalon-or (gold). Modes : simple, double avec arbitrage, consensus, annotation assistée (pré-étiquetage par modèle), active (le modèle choisit les exemples à annoter).

Définition (bruit d’étiquettes). Fraction d’étiquettes fausses ; symétrique (uniforme) ou dépendant de la classe/de l’entrée. Détection : désaccords, perte élevée après entraînement (confident learning), ré-annotation d’un échantillon.

Définition (doublon, quasi-doublon). Exact : même contenu (hash). Quasi : contenu presque identique (similarité de Jaccard sur n-grammes > seuil, plongements proches). Les doublons entre train et test gonflent les scores ; dans le train, ils sur-pondèrent et favorisent la mémorisation.

Définition (fuite). Toute information présente à l’entraînement qui ne sera pas disponible en production, ou qui provient du futur ou du test : variables proxy de la cible, prétraitement ajusté sur tout le jeu, doublons train/test, groupes partagés, ordre temporel violé.

Définition (séparation). Aléatoire (données i.i.d.), par groupe (un patient, un robot, un utilisateur entier dans un seul sous-ensemble), temporelle (test = période future), stratifiée (proportions des classes conservées). Le test est scellé (L32).

Définition (données synthétiques, augmentation). Synthétiques : générées par simulation, règles ou modèle (LLM) ; augmentation : transformations d’exemples réels préservant l’étiquette (rotations, bruit, paraphrases). Utiles pour la rareté et l’équilibre ; risquent de reproduire les biais du générateur et de dégrader par effondrement (model collapse) si réutilisées en boucle.

Définition (datasheet, licence, consentement). Documentation (Gebru 2018) : motivation, composition, collecte, prétraitement, usages, distribution, maintenance. Licence des données (CC, ODbL, propriétaire, conditions de site) ; base légale (RGPD : consentement, intérêt légitime ; données sensibles ; droit à l’effacement).

Fiche de cours · Formules

Formules à connaître

Taille d’un jeu de test pour une exactitude p à ±e (95 %) : n ≥ 1,96²·p(1−p)/e² ; pour ±2 points autour de 80 % : 1 537 cas

Taille d’entraînement (règle empirique) : erreur ≈ a + b/n^c (loi de puissance, c ≈ 0,3–0,5) ; tracer la courbe d’apprentissage sur 10 %, 20 %, 50 %, 100 % et extrapoler

Kappa de Cohen κ = (p_o − p_e)/(1 − p_e) ; alpha de Krippendorff α = 1 − D_o/D_e (multi-annotateurs, données manquantes, distances variées) ; cibles : κ ≥ 0,7 pour une tâche « bien définie »

Bruit symétrique de taux η : un classifieur entraîné avec la perte 0-1 atteint la même solution optimale si η < ½ (Natarajan 2013) ; mais la variance et le sur-apprentissage augmentent ; l’exactitude mesurée sur un test bruité est plafonnée à ≈ 1 − η

Jaccard(A, B) = |A ∩ B|/|A ∪ B| sur les ensembles de shingles (n-grammes) ; MinHash : P(h_min(A) = h_min(B)) = Jaccard(A, B) ; avec k fonctions, estimation ± 1/√k

LSH par bandes (b bandes de r lignes, br = k) : P(candidat) = 1 − (1 − s^r)^b — courbe en S avec seuil ≈ (1/b)^1/r

Coût d’annotation = n × temps par exemple × taux horaire × (1 + fraction doublement annotée) + conception de la consigne + arbitrage

Déséquilibre : sur-échantillonner la minorité, sous-échantillonner la majorité, ou pondérer la perte par 1/fréquence ; SMOTE (interpolation) pour le tabulaire ; jamais sur le test

Z-score |x − μ|/σ > 3 ou IQR (x < Q₁ − 1,5·IQR ou > Q₃ + 1,5·IQR) pour les valeurs aberrantes univariées ; isolation forest / LOF en multidimensionnel

Imputation : moyenne/médiane (biais de variance), par modèle (KNN, régression), indicateur de valeur manquante en variable supplémentaire ; MCAR / MAR / MNAR déterminent ce qui est valide

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

Démonstrations à savoir refaire

Théorème 1 (MinHash estime Jaccard). Pour une permutation aléatoire π des shingles, P(min π(A) = min π(B)) = J(A, B).

Le minimum de π sur A ∪ B est atteint sur un élément uniformément aléatoire de A ∪ B (la permutation est aléatoire). min π(A) = min π(B) ssi cet élément est dans A ∩ B. Probabilité |A ∩ B|/|A ∪ B| = J. Avec k permutations indépendantes (en pratique k fonctions de hachage), la fraction d’égalités est un estimateur sans biais de J, de variance J(1 − J)/k. Une signature de k = 128 entiers (512 octets) remplace un document de plusieurs Mo pour la comparaison : c’est ce qui rend la déduplication de 10⁹ documents possible (Broder 1997 ; utilisé pour C4, The Pile, RefinedWeb).

Théorème 2 (LSH par bandes : la courbe en S). Avec une signature de br valeurs découpée en b bandes de r valeurs, deux documents de similarité s deviennent candidats (identiques sur au moins une bande) avec probabilité 1 − (1 − s^r)^b.

Par le Théorème 1, chaque valeur de signature coïncide avec probabilité s ; une bande entière (r valeurs) coïncide avec probabilité s^r (indépendance) ; aucune bande ne coïncide avec probabilité (1 − s^r)^b. La fonction est proche de 0 pour s petit, de 1 pour s grand, avec un seuil vers (1/b)^1/r : pour b = 20, r = 5 : s ≈ 0,55. On ne compare donc que les paires candidates (mêmes buckets), en temps ≈ linéaire, au lieu de n²/2 paires.

Théorème 3 (un doublon train/test surestime l’exactitude). Si une fraction d du jeu de test est dupliquée dans le train et que le modèle mémorise (exactitude 1 sur ces cas) tandis que l’exactitude réelle est a, l’exactitude mesurée est a + d(1 − a).

Mesurée = d × 1 + (1 − d) × a = a + d(1 − a). Avec d = 10 % et a = 0,80 : 0,82 — un « gain » de 2 points qui ne correspond à rien. Pour les LLM, la contamination des benchmarks (L32) est ce mécanisme à l’échelle du web ; pour un jeu interne, elle vient des copier-coller, des versions multiples d’un document, des exports répétés. Déduplication avant la séparation, exacte et approximative, et par groupe (un document et ses versions dans le même sous-ensemble).

Théorème 4 (le bruit d’étiquettes plafonne l’exactitude mesurée et la borne inférieure de l’accord). Si les étiquettes du test sont fausses avec probabilité η (symétrique, binaire), l’exactitude mesurée d’un classifieur parfait est 1 − η ; et deux annotateurs indépendants de taux d’erreur η s’accordent avec probabilité (1 − η)² + η².

Un classifieur parfait est « en désaccord » avec l’étiquette exactement quand elle est fausse : exactitude mesurée 1 − η. Deux annotateurs s’accordent s’ils ont tous deux raison ((1 − η)²) ou tous deux tort de la même façon (η² en binaire). Pour η = 0,1 : accord 0,82, et un modèle à 90 % « réel » affiche 81–90 % selon la corrélation de ses erreurs avec celles des annotateurs. Conséquence : un plafond de performance apparent peut être un plafond d’annotation ; ré-annoter un échantillon du test en double, avec arbitrage, avant de chercher un meilleur modèle.

01 / Concevoir

Du besoin au plan de collecte : population, échantillonnage, budget

import numpy as np
# 1) Taille du jeu de test pour la précision voulue
def n_test(p, e, z=1.96): return int(np.ceil(z**2 * p * (1 - p) / e**2))
for p, e in ((0.8, 0.05), (0.8, 0.02), (0.95, 0.01)): print(f"exactitude ≈ {p:.2f} à ± {e:.2f} → {n_test(p, e):5d} cas de test")
# 2) Classes rares : pour avoir au moins k exemples de la classe rare dans le test
def n_pour_classe_rare(prevalence, k): return int(np.ceil(k / prevalence))
print(f"\n50 exemples d'une classe à 2 % → {n_pour_classe_rare(0.02, 50)} cas au total (ou stratifier / sur-collecter la classe rare et pondérer)")
# 3) Budget d'annotation
def budget(n, sec_par_ex, taux_h, double=0.2, conception_h=16, arbitrage_frac=0.05):
    heures = n * sec_par_ex / 3600 * (1 + double) + conception_h + n * arbitrage_frac * sec_par_ex * 2 / 3600; return heures, heures * taux_h
for n in (1000, 5000, 20000):
    h, c = budget(n, 45, 35); print(f"{n:6d} exemples à 45 s, 20 % en double, arbitrage 5 % : {h:6.0f} h, {c:7.0f} €")
# 4) Courbe d'apprentissage pour dimensionner l'entraînement : erreur ≈ a + b n^(−c) ajustée sur des sous-ensembles
n_sub = np.array([200, 500, 1000, 2000, 4000]); err = np.array([0.31, 0.24, 0.20, 0.17, 0.155])       # mesuré (simulé)
A = np.c_[np.ones(5), n_sub ** -0.4]; a, b = np.linalg.lstsq(A, err, rcond=None)[0]
for n in (8000, 16000, 50000): print(f"prédiction à n = {n:6d} : erreur ≈ {a + b * n**-0.4:.3f} (plancher a ≈ {a:.3f})")
print("→ si le plancher est trop haut, plus de données ne suffira pas : revoir les variables, la consigne, le bruit d'étiquettes.")

Question de conception	Réponse à écrire avant de collecter
Population cible	Qui/quoi, où, quand, dans quelles conditions (capteurs, langues, saisons, appareils)
Unité d’exemple	Une image, une phrase, un document, une séquence de 10 s ? Une décision par unité
Étiquette	Définition opérationnelle, valeurs autorisées, cas limites tranchés, exemples
Sources et droits	Origine, licence, consentement, données personnelles, durée de conservation
Échantillonnage	Aléatoire ? stratifié par condition ? sur-collecte des cas rares ? période ?
Métadonnées	Tout ce qui permettra les tranches (L32) et les séparations par groupe

02 / Annoter

Consigne, accord inter-annotateurs, arbitrage — et l’annotation active

import numpy as np
from collections import Counter
rng = np.random.default_rng(0)
def kappa(a, b):
    a, b = np.asarray(a), np.asarray(b); cats = sorted(set(a) | set(b)); po = np.mean(a == b)
    pe = sum(np.mean(a == c) * np.mean(b == c) for c in cats); return (po - pe) / (1 - pe)
def alpha_krippendorff(matrice):
    """matrice : (annotateurs, items) avec None pour manquant ; données nominales."""
    valeurs = [[v for v in col if v is not None] for col in zip(*matrice)]; valeurs = [v for v in valeurs if len(v) >= 2]
    n = sum(len(v) for v in valeurs); tot = Counter(x for v in valeurs for x in v)
    Do = sum(sum(1 for i in range(len(v)) for j in range(len(v)) if i != j and v[i] != v[j]) / (len(v) - 1) for v in valeurs) / n
    De = sum(tot[c] * tot[d] for c in tot for d in tot if c != d) / (n * (n - 1)); return 1 - Do / De
# Simulation : consigne v1 (ambiguë) puis v2 (cas limites tranchés) sur 300 tickets en 4 classes
verite = rng.integers(0, 4, 300)
def annoter(verite, bruit, biais_classe=None):
    out = verite.copy(); m = rng.random(len(verite)) < bruit; out[m] = rng.integers(0, 4, m.sum())
    if biais_classe is not None: out[(verite == 2) & (rng.random(len(verite)) < 0.5)] = biais_classe          # confusion systématique 2 → 3
    return out
a1, b1 = annoter(verite, 0.15, 3), annoter(verite, 0.15, 3); a2, b2 = annoter(verite, 0.06), annoter(verite, 0.06)
print(f"consigne v1 : accord brut {np.mean(a1 == b1):.2f}, kappa {kappa(a1, b1):.2f} | matrice de désaccord dominante :", Counter(zip(a1[a1 != b1], b1[a1 != b1])).most_common(2))
print(f"consigne v2 : accord brut {np.mean(a2 == b2):.2f}, kappa {kappa(a2, b2):.2f}")
print("alpha de Krippendorff (3 annotateurs, données partielles) :", round(alpha_krippendorff([list(a2), list(b2), [x if i % 3 else None for i, x in enumerate(annoter(verite, 0.06))]]), 3))
print("\nLa matrice de désaccord (2 ↔ 3) pointe la définition à préciser : c'est ainsi qu'on itère la consigne, avec un lot pilote de 100 exemples.")
# Annotation active : annoter d'abord les exemples où le modèle est le moins sûr (marge minimale) — gain typique ×2–5 en exemples pour la même exactitude
scores = rng.random((2000, 4)); scores /= scores.sum(1, keepdims=True); marge = np.sort(scores, 1)[:, -1] - np.sort(scores, 1)[:, -2]
print(f"\nannotation active : 200 exemples à annoter en priorité = ceux de marge minimale (marge médiane {np.median(marge):.2f}, sélectionnés < {np.sort(marge)[200]:.2f}) ;")
print("attention : le jeu ainsi construit n'est plus représentatif → le TEST reste un échantillon aléatoire.")

03 / Nettoyer

Schéma, valeurs manquantes et aberrantes, étiquettes bruitées — sur un jeu réaliste

import numpy as np, re
rng = np.random.default_rng(1)
# Journal de mesures d'un robot exporté de trois sources : unités mélangées, valeurs manquantes, aberrantes, doublons, formats hétérogènes
n = 2000
dist = np.abs(rng.normal(2.0, 0.8, n)); dist[rng.random(n) < 0.05] *= 100                     # 5 % en cm au lieu de m (source B)
dist[rng.random(n) < 0.03] = np.nan; dist[rng.random(n) < 0.01] = -1                           # manquants ; code d'erreur -1
temp = rng.normal(45, 8, n); temp[rng.random(n) < 0.02] = 999                                  # valeur sentinelle
etiq = np.where(dist < 1.0, "proche", "loin").astype(object); flip = rng.random(n) < 0.08; etiq[flip] = np.where(etiq[flip] == "proche", "Loin ", "PROCHE")   # casse/espaces + 8 % d'erreurs réelles
idx = np.r_[np.arange(n), rng.integers(0, n, 150)]                                             # 150 doublons exacts
dist, temp, etiq = dist[idx], temp[idx], etiq[idx]
print(f"brut : {len(dist)} lignes, {np.isnan(dist).sum()} distances manquantes, {(dist == -1).sum()} codes -1, {(temp == 999).sum()} sentinelles 999, étiquettes :", dict(zip(*np.unique(etiq.astype(str), return_counts=True))))
# 1) Schéma et normalisation des étiquettes
etiq_n = np.array([e.strip().lower() for e in etiq]); assert set(etiq_n) <= {"proche", "loin"}
# 2) Codes d'erreur et sentinelles → NaN (ne jamais les laisser comme des nombres)
dist = np.where(dist == -1, np.nan, dist); temp = np.where(temp == 999, np.nan, temp)
# 3) Doublons exacts (sur les colonnes de contenu)
cle = np.array([f"{d:.6f}|{t:.6f}|{e}" for d, t, e in zip(dist, temp, etiq_n)]); _, premiers = np.unique(cle, return_index=True); garder = np.zeros(len(cle), bool); garder[premiers] = True
print(f"doublons exacts retirés : {(~garder).sum()}")
dist, temp, etiq_n = dist[garder], temp[garder], etiq_n[garder]
# 4) Unités : distribution bimodale → détecter et convertir (règle métier : > 30 m impossible pour ce capteur)
suspect = dist > 30; print(f"valeurs > 30 m (probablement en cm) : {suspect.sum()} → converties"); dist = np.where(suspect, dist / 100, dist)
# 5) Aberrantes restantes par IQR
q1, q3 = np.nanpercentile(dist, [25, 75]); iqr = q3 - q1; ab = (dist < q1 - 1.5 * iqr) | (dist > q3 + 1.5 * iqr); print(f"aberrantes IQR : {np.nansum(ab)} (à inspecter, pas à supprimer aveuglément)")
# 6) Manquants : mécanisme ? Ici MCAR (aléatoire) → imputation médiane + indicateur
manq = np.isnan(dist); dist_imp = np.where(manq, np.nanmedian(dist), dist); print(f"imputés : {manq.sum()} (+ colonne indicatrice 'dist_manquante')")
# 7) Étiquettes bruitées : incohérence règle ↔ étiquette (ici la règle est connue ; en général : confident learning, désaccords, ré-annotation)
regle = np.where(dist_imp < 1.0, "proche", "loin"); incoh = regle != etiq_n; print(f"étiquettes incohérentes avec la règle métier : {incoh.sum()} ({incoh.mean():.1%}) → file de ré-annotation")
print(f"\npropre : {len(dist_imp)} lignes ; chaque étape est journalisée (combien, pourquoi) : le nettoyage fait partie du jeu de données.")

03 / Nettoyer

Déduplication approximative : MinHash et LSH implémentés (Théorèmes 1 et 2)

import numpy as np, re, hashlib
from collections import defaultdict
rng = np.random.default_rng(2)
def shingles(texte, n=3):
    mots = re.findall(r"\w+", texte.lower()); return {" ".join(mots[i:i + n]) for i in range(max(1, len(mots) - n + 1))}
def jaccard(a, b): return len(a & b) / len(a | b)
def minhash(sh, k=64):
    sig = np.full(k, np.iinfo(np.uint64).max, dtype=np.uint64)
    for s in sh:
        h = int(hashlib.md5(s.encode()).hexdigest(), 16)
        for i in range(k):                                                   # k fonctions : h_i(x) = (a_i·h + b_i) mod p
            v = (A[i] * (h % P) + B[i]) % P
            if v < sig[i]: sig[i] = v
    return sig
P = (1 << 61) - 1; A = rng.integers(1, P, 64, dtype=np.int64).astype(object); B = rng.integers(0, P, 64, dtype=np.int64).astype(object)
base = "le robot avance de deux mètres puis tourne à gauche et s'arrête devant l'obstacle avant de reprendre sa route vers la station de charge"
docs = {"d1": base, "d2": base.replace("deux", "trois"), "d3": base + " en évitant les câbles au sol", "d4": "le lidar mesure la distance à 5,5 Hz avec une portée de douze mètres", "d5": " ".join(base.split()[::-1]), "d6": base}
sh = {k: shingles(v) for k, v in docs.items()}; sig = {k: minhash(v) for k, v in sh.items()}
print(f"{'paire':8s} {'Jaccard':>8s} {'MinHash':>8s}")
for a, b in (("d1", "d2"), ("d1", "d3"), ("d1", "d4"), ("d1", "d5"), ("d1", "d6")): print(f"{a}-{b}    {jaccard(sh[a], sh[b]):8.2f} {np.mean(sig[a] == sig[b]):8.2f}")
# LSH : b bandes de r lignes ; candidats = même bucket sur au moins une bande
def lsh(signatures, b=16, r=4):
    buckets = defaultdict(set)
    for k, s in signatures.items():
        for i in range(b): buckets[(i, tuple(s[i * r:(i + 1) * r]))].add(k)
    cand = set()
    for grp in buckets.values():
        for x in grp:
            for y in grp:
                if x < y: cand.add((x, y))
    return cand
print("\ncandidats LSH (b = 16, r = 4, seuil ≈ (1/16)^(1/4) = 0,5) :", sorted(lsh(sig)))
s = np.linspace(0, 1, 11); print("P(candidat) selon la similarité :", [f"{x:.1f}:{1 - (1 - x**4)**16:.2f}" for x in s])
print("→ d5 (mêmes mots, ordre inversé) n'est PAS un doublon pour des 3-grammes : le choix des shingles définit ce que 'doublon' veut dire.")

À l’échelle (10⁹ documents) : signatures sur GPU/Spark, LSH distribué (text-dedup, datasketch), déduplication de sous-chaînes par suffix array (Lee et al. 2022). La déduplication améliore la perplexité des LLM et réduit la mémorisation — un des rares traitements qui gagnent sur les deux tableaux.

04 / Séparer et protéger

Fuites, séparations par groupe et par temps, équilibrage — vérifiés par le code

import numpy as np
rng = np.random.default_rng(3)
# Données : 600 sessions de 5 mesures d'un même robot chacune (groupe) ; 40 robots ; une variable "fuyante" (identifiant de session corrélé à la cible)
n_robots, sessions_par_robot, mesures = 40, 15, 5
robot = np.repeat(np.arange(n_robots), sessions_par_robot * mesures); session = np.repeat(np.arange(n_robots * sessions_par_robot), mesures); t = np.arange(len(robot))
x = rng.normal(0, 1, (len(robot), 3)) + rng.normal(0, 0.8, n_robots)[robot, None]                # effet robot (les mesures d'un même robot se ressemblent)
y = ((x[:, 0] + 0.5 * x[:, 1] + rng.normal(0, 0.8, len(robot))) > 0).astype(int)
def knn_acc(Xtr, ytr, Xte, yte, k=5):
    d = ((Xte[:, None, :] - Xtr[None, :, :]) ** 2).sum(-1); idx = np.argsort(d, 1)[:, :k]; return np.mean((ytr[idx].mean(1) > 0.5) == yte)
# 1) Séparation aléatoire par ligne (FUITE : les autres mesures de la même session/robot sont dans le train)
perm = rng.permutation(len(y)); tr, te = perm[:2400], perm[2400:]
acc_ligne = knn_acc(x[tr], y[tr], x[te], y[te])
# 2) Par groupe (robot) : réaliste si le modèle servira sur des robots jamais vus
rob_te = rng.choice(n_robots, 8, replace=False); m = np.isin(robot, rob_te)
acc_groupe = knn_acc(x[~m], y[~m], x[m], y[m])
# 3) Temporelle : entraîner sur le passé, tester sur le futur
m_t = t >= int(0.8 * len(t)); acc_temps = knn_acc(x[~m_t], y[~m_t], x[m_t], y[m_t])
print(f"exactitude k-NN — séparation par ligne {acc_ligne:.3f} (optimiste : fuite de groupe) | par robot {acc_groupe:.3f} | temporelle {acc_temps:.3f}")
# 4) Fuite par variable proxy : ajouter 'identifiant de session' comme variable → score parfait en aléatoire, nul en production
x_fuite = np.c_[x, session / session.max() * 5]; print(f"avec l'identifiant de session en variable : {knn_acc(x_fuite[tr], y[tr], x_fuite[te], y[te]):.3f} (séparation par ligne) — un score trop beau est une fuite jusqu'à preuve du contraire")
# 5) Prétraitement : standardiser avec les statistiques du TRAIN seulement
mu, sd = x[~m].mean(0), x[~m].std(0); x_te_ok = (x[m] - mu) / sd                                # jamais x.mean(0) sur tout le jeu
# 6) Déséquilibre : pondération de la perte (1/fréquence) ou ré-échantillonnage du train seulement
freq = np.bincount(y[~m]) / (~m).sum(); print("poids de classe pour la perte :", (1 / freq / (1 / freq).sum() * 2).round(2), "— appliqués au train ; le test garde ses proportions réelles")
print("\nRègle : la séparation reproduit la façon dont le modèle sera UTILISÉ (nouveaux robots ? nouveau mois ?) ; sinon le score ne prédit rien.")

05 / Données pour LLM

Corpus de pré-entraînement et d’affinage : filtrage, déduplication, synthèse, contamination

Étape	Ce qu’on fait	Exemples / chiffres	Piège
Collecte	Common Crawl (pétaoctets), livres, code, articles, forums ; corpus internes	RefinedWeb : 5 000 G tokens → 600 G après filtrage ; FineWeb 15 T tokens	Droits d’auteur, données personnelles, robots.txt
Extraction	HTML → texte (trafilatura), langue (fastText), encodage	Perte de 50–80 % du volume brut	Menus, pubs, texte dupliqué de gabarit
Filtrage de qualité	Heuristiques (longueur, ponctuation, ratio de symboles, répétitions), classifieurs de qualité (entraînés sur Wikipédia/livres vs web), perplexité d’un petit LM	Gopher rules ; C4 : lignes sans point final retirées	Biais : le « bon anglais » filtre les dialectes et les langues rares
Déduplication	Exacte (hash de documents/lignes), quasi (MinHash LSH), sous-chaînes (suffix array)	Lee et al. 2022 : −10 % de perplexité à calcul égal, mémorisation ÷10	Dédupliquer aussi contre les jeux de test (contamination)
Décontamination	Retirer tout document contenant des n-grammes des benchmarks (13-grammes)	GPT-3 : 13-gram overlap ; toujours imparfait (paraphrases)	Impossible à garantir ; d’où les jeux privés (L32)
Mélange et pondération	Proportions par source (web 80 %, code 10 %, livres…), sur-échantillonnage des sources rares de qualité	Le mélange influence les capacités (code → raisonnement)	Époques multiples sur les données rares : rendements décroissants après 4 (Muennighoff 2023)
Données d’instruction	Paires (instruction, réponse) écrites par des humains, ou générées puis filtrées (Self-Instruct, Evol-Instruct), préférences (paires)	LIMA : 1 000 exemples de haute qualité suffisent pour l’alignement de base	Réponses générées par un modèle = ses biais et ses erreurs ; licences des sorties
Données synthétiques	Simulation, LLM générateur + vérificateur (code exécuté, maths vérifiées)	Phi : manuels synthétiques ; robotique : sim-to-real	Effondrement du modèle si l’on entraîne en boucle sur ses propres sorties (Shumailov 2024)

06 / Documenter et versionner

Datasheet, schéma, version : le jeu de données comme artefact logiciel

# DATASHEET — obstacles-robot-v3 (extrait)
Motivation : entraîner et évaluer la détection d'obstacles du robot R2 en intérieur (couloirs, ateliers) ; commanditaire : équipe navigation.
Composition : 24 310 images 640×480 (RGB) + 24 310 scans lidar synchronisés ; 3 sites, 11 robots, 2025-11 → 2026-06 ; classes : sol, mur,
  obstacle_statique, humain, vide ; 7 % 'humain' ; 1 130 images avec ≥ 2 annotateurs (kappa 0,81) ; étalon-or : 500 images arbitrées.
Collecte : capture automatique 1 img/s pendant les missions ; échantillonnage stratifié par site et par heure ; humains floutés (RGPD, base
  légale : intérêt légitime, information affichée sur site) ; aucune donnée hors des sites partenaires.
Prétraitement : déduplication exacte (hash) et approximative (pHash < 6) → −2 140 ; images floues (variance du laplacien < 50) → −310 ;
  étiquettes normalisées ; 41 conflits arbitrés. Script : prep/clean.py @ a1f3c9e.
Séparation : par ROBOT (test = 3 robots jamais vus) et par période (test = 2026-05/06) ; train 17 800 / val 2 900 / test 3 610 ; test scellé (hash).
Usages : détection et segmentation ; NON prévu : reconnaissance de personnes. Licence : interne ; contact : navigation@…
Maintenance : version trimestrielle ; erreurs signalées via le formulaire ; changelog ci-dessous.
Versions : v1 (2026-01, 8 000 img) → v2 (2026-04, +site C) → v3 (2026-07, déduplication, nouvelle consigne 'humain partiel').

07 / Articles

Les articles à lire

Article	Contribution	À retenir
Gebru et al., Datasheets for Datasets, 2018 — 1803.09010	Documentation standardisée	Le modèle de la partie 06
Broder, On the resemblance and containment of documents, 1997 ; Leskovec, Rajaraman & Ullman, Mining of Massive Datasets, chap. 3	MinHash, LSH	Théorèmes 1 et 2
Lee et al., Deduplicating Training Data Makes Language Models Better, ACL 2022 — 2107.06499	Déduplication exacte + approximative des corpus LLM	Moins de mémorisation, meilleure perplexité
Northcutt, Jiang & Chuang, Confident Learning, JAIR 2021 — 1911.00068 ; Northcutt et al., Pervasive Label Errors in Test Sets, NeurIPS 2021 — 2103.14749	Détecter les étiquettes fausses ; 3,4 % d’erreurs dans les tests standard (ImageNet 6 %)	Théorème 4 ; cleanlab
Natarajan et al., Learning with Noisy Labels, NeurIPS 2013	Théorie du bruit d’étiquettes	Pertes corrigées ; le bruit < ½ est surmontable
Settles, Active Learning Literature Survey, 2009	Annotation active	Incertitude, diversité ; le test reste aléatoire
Kaufman et al., Leakage in Data Mining, TKDD 2012	Taxonomie des fuites	Un score trop beau est une fuite jusqu’à preuve du contraire
Penedo et al., The RefinedWeb Dataset, 2023 — 2306.01116 ; FineWeb, 2024 — 2406.17557	Pipelines de filtrage web à l’échelle, ablations	Ce que chaque filtre change, mesuré
Zhou et al., LIMA: Less Is More for Alignment, 2023 — 2305.11206	1 000 exemples de qualité	Qualité > quantité pour l’affinage
Shumailov et al., AI models collapse when trained on recursively generated data, Nature 2024	Effondrement du modèle	Garder des données réelles ; tracer la provenance
Sambasivan et al., “Everyone wants to do the model work, not the data work”, CHI 2021	Cascades de données dans les projets IA	Les échecs viennent des données négligées
Rubin, Inference and Missing Data, Biometrika 1976	MCAR / MAR / MNAR	Le mécanisme des manquants décide de l’imputation valide

TP guidé

TP — Un jeu de données from scratch, documenté (6 h)

Concevoir. Une tâche réelle (classification de tickets, détection sur images du robot, extraction sur documents). Remplir le tableau de conception (population, unité, étiquette, sources/droits, échantillonnage, métadonnées) et le budget.
Consigne et pilote. Rédiger la consigne (définitions, cas limites, 10 exemples) ; annoter 100 exemples à deux (Label Studio ou Argilla) ; kappa et matrice de désaccord ; itérer la consigne ; annoter 1 000 (20 % en double, arbitrage).
Nettoyer. Schéma (pandera/Great Expectations), doublons exacts et MinHash, valeurs manquantes (mécanisme), aberrantes, étiquettes suspectes (cleanlab) ; journal de nettoyage chiffré.
Séparer. Par groupe ou temps selon l’usage ; vérifier l’absence de fuite (doublons croisés, variables proxy : entraîner un modèle et regarder l’importance des variables) ; sceller le test (hash).
Documenter et versionner. Datasheet complète ; DVC (ou LakeFS) avec v1 ; un notebook d’exploration (distributions, tranches, biais visibles).
Livrable. Dépôt versionné, datasheet, consigne, mesures d’accord, journal de nettoyage, et une page « ce que ce jeu ne permet pas de conclure ».

Exercices

Exercices auto-corrigés

Exercice 1 — Kappa et alpha

Implémentez kappa_cohen(a, b) et kappa_pondere(a, b, K) (pondération quadratique pour des catégories ordinales 0..K−1 : poids w_ij = (i − j)²/(K − 1)²). Vérifiez : κ = 1 pour l’accord parfait ; κ ≈ 0 pour des annotations indépendantes ; le kappa pondéré pénalise moins un désaccord d’un cran qu’un désaccord de trois crans.

Correction

def kappa_cohen(a, b):
    a, b = np.asarray(a), np.asarray(b); cats = sorted(set(a) | set(b)); po = np.mean(a == b)
    pe = sum(np.mean(a == c) * np.mean(b == c) for c in cats); return (po - pe) / (1 - pe)
def kappa_pondere(a, b, K):
    a, b = np.asarray(a).astype(np.intp), np.asarray(b).astype(np.intp); n = len(a); O = np.zeros((K, K)); np.add.at(O, (a, b), 1); O /= n
    E = np.outer(np.bincount(a, minlength=K) / n, np.bincount(b, minlength=K) / n)
    W = np.array([[(i - j) ** 2 for j in range(K)] for i in range(K)]) / (K - 1) ** 2
    return 1 - (W * O).sum() / (W * E).sum()

Exercice 2 — MinHash et sa précision

Écrivez minhash_simple(ensemble, k, graine) avec des fonctions de hachage h_i(x) = hash((i, x)) (via hashlib), et similarite(sigA, sigB). Vérifiez sur des ensembles de Jaccard connu que l’erreur d’estimation décroît en 1/√k.

Correction

def minhash_simple(ensemble, k=64, graine=0):
    sig = []
    for i in range(k):
        sig.append(min(int(hashlib.blake2b(f"{graine}|{i}|{x}".encode(), digest_size=8).hexdigest(), 16) for x in ensemble))
    return np.array(sig)
def similarite(sa, sb): return float(np.mean(sa == sb))

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Séparation par groupe sans fuite

Écrivez separer_par_groupe(groupes, frac_test, rng) qui renvoie un masque booléen du test tel qu’aucun groupe ne soit à cheval et que la fraction de lignes en test soit ≈ frac_test (±0,05), et verifier_fuite(train_ids, test_ids) qui renvoie le nombre d’identifiants (doublons) communs.

Correction

def separer_par_groupe(groupes, frac_test=0.2, rng=None):
    rng = rng or np.random.default_rng(0); g = np.unique(groupes); rng.shuffle(g); tailles = {x: (groupes == x).sum() for x in g}
    test, total = set(), 0
    for x in g:
        if total / len(groupes) >= frac_test: break
        test.add(x); total += tailles[x]
    return np.isin(groupes, list(test))
def verifier_fuite(train_ids, test_ids): return len(set(train_ids) & set(test_ids))

Exercice 4 — Détection d’étiquettes bruitées par validation croisée

Implémentez etiquettes_suspectes(X, y, k_plis, seuil) : entraîner un classifieur simple (centroïdes par classe) sur k−1 plis, prédire les probabilités sur le pli restant (softmax des −distances), et renvoyer les indices dont la probabilité de l’étiquette annotée est < seuil. Vérifiez que sur des données avec 10 % d’étiquettes inversées, la précision de la détection et le rappel dépassent 0,6.

Correction

def etiquettes_suspectes(X, y, k_plis=5, seuil=0.2):
    n = len(y); K = y.max() + 1; plis = np.arange(n) % k_plis; suspects = []
    for p in range(k_plis):
        tr, te = plis != p, plis == p
        centres = np.array([X[tr][y[tr] == c].mean(0) for c in range(K)])
        d = ((X[te][:, None, :] - centres[None, :, :]) ** 2).sum(-1); z = -d; z -= z.max(1, keepdims=True); pr = np.exp(z); pr /= pr.sum(1, keepdims=True)
        idx = np.where(te)[0]; suspects += [int(i) for i, row, lab in zip(idx, pr, y[te]) if row[lab] < seuil]
    return suspects

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Un modèle de tri de courriels atteint 97 % en validation, 71 % en production. Lister les causes probables liées aux données et le test qui les confirme.

Correction. (1) Fuite : variable proxy (identifiant, horodatage corrélé au libellé, champ rempli après coup) — test : importance des variables, ré-entraîner sans les suspects. (2) Doublons train/val (fils de discussion, réponses citant le message) — test : déduplication exacte + MinHash entre train et val ; séparation par fil de discussion. (3) Séparation aléatoire alors que la production est temporelle (nouveaux sujets) — test : validation temporelle. (4) Population différente : val = courriels d’un service, prod = tous — test : dérive (L35) entre val et prod, tranches par service. (5) Étiquettes de val produites par une règle que le modèle a apprise (validation circulaire) — test : ré-annotation humaine d’un échantillon. (6) Prétraitement ajusté sur tout le jeu. Ordre : (2) et (3) sont les plus fréquents.

Exercice 2. Deux annotateurs ont un kappa de 0,45 sur une tâche de sentiment à 5 niveaux. Que faire avant d’entraîner ?

Correction. 0,45 = accord modéré : le bruit d’étiquettes plafonnera le modèle (Théorème 4) et l’évaluation. Actions : (1) matrice de désaccord — si les désaccords sont surtout entre niveaux adjacents (3 vs 4), le kappa pondéré sera bien meilleur et l’on peut fusionner des niveaux (5 → 3) ou traiter la tâche comme ordinale/régression ; (2) préciser la consigne sur les cas limites identifiés, avec exemples ancrés ; (3) lot pilote de 100, re-mesurer, itérer jusqu’à κ ≥ 0,7 ; (4) annoter le test en triple avec vote/arbitrage (étalon-or), et le train en simple avec un échantillon en double pour estimer η ; (5) si la tâche est intrinsèquement subjective, conserver les étiquettes multiples (distribution) plutôt qu’un vote, et évaluer par la log-vraisemblance de cette distribution.

Exercice 3. On propose de générer 50 000 exemples synthétiques par LLM pour entraîner un classifieur de tickets, faute de données annotées. Avantages, risques, protocole.

Correction. Avantages : volume et couverture rapides, équilibrage des classes rares, coût faible, pas de données personnelles. Risques : distribution différente des vrais tickets (style trop propre, vocabulaire du modèle), étiquettes fausses (le générateur se trompe sur les cas limites), biais du générateur reproduits, effondrement si réutilisé en boucle, licence des sorties. Protocole : (1) partir de 300 vrais tickets annotés (test scellé + amorces) ; (2) générer conditionnellement à des exemples réels et à la consigne d’annotation, avec diversité contrôlée (température, personas) ; (3) filtrer : déduplication, classifieur de « réalisme » (réel vs synthétique — s’il sépare facilement, les synthétiques sont hors distribution), vérification d’un échantillon par humains (précision des étiquettes ≥ 95 %) ; (4) entraîner sur synthétique + réel, évaluer uniquement sur le réel, comparer à réel seul et à synthétique seul ; (5) courbe : quelle quantité de synthétique aide encore ; (6) tracer la provenance de chaque exemple et ne jamais faire entrer de synthétique dans le test.

Vérification

Un jeu contient 5 mesures par session et 15 sessions par robot. Le modèle servira sur de nouveaux robots. Comment séparer train et test ?

Deux questions supplémentaires

1. Que fait MinHash ? Estime la similarité de Jaccard par des signatures courtes ; LSH ne compare que les candidats probables (Théorèmes 1–2).

2. Pourquoi ré-annoter un échantillon du test avant de chercher un meilleur modèle ? Le bruit d’étiquettes plafonne l’exactitude mesurée (Théorème 4).

Référence

Les mots à retenir

Mot	Définition
Population / échantillon	Ce sur quoi le modèle servira / ce qu’on a collecté ; biais entre les deux.
Consigne, kappa, étalon-or	Définition opérationnelle, accord corrigé du hasard, référence arbitrée.
Bruit d’étiquettes	Plafonne la mesure ; détecter par désaccords et confident learning.
Doublon, MinHash, LSH	Exact / approximatif ; signatures ; bandes.
Fuite	Information indisponible en production présente à l’entraînement.
Séparation par groupe / temps	Reproduire l’usage ; test scellé.
Datasheet	Motivation, composition, collecte, prétraitement, usages, maintenance.
Données synthétiques	Utiles avec filtrage et évaluation sur réel ; risque d’effondrement.

Suite

Avant d’entraîner quoi que ce soit : l’escalade des solutions.

Chapitre suivant : les étapes avant « je crée mon modèle from scratch » — règles, modèles existants, prompt, RAG, affinage léger, affinage complet, pré-entraînement — avec, pour chacune, limites, contraintes et avantages.

← L35 Sommaire L37 : avant le from scratch →