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

Créer un modèle : l’escalade des solutions, et où s’arrêter.

« Je vais entraîner mon propre modèle » est presque toujours la mauvaise première phrase. Entre « pas de modèle » et « pré-entraînement from scratch », il y a huit paliers — règles et heuristiques, modèle classique, modèle pré-entraîné en zero-shot, prompt et few-shot, RAG et outils, affinage léger (LoRA, têtes), affinage complet, pré-entraînement — chacun avec ses limites, ses contraintes, ses avantages, son coût et son délai. Ce chapitre donne la règle de décision pour monter d’un palier (jamais deux), les mathématiques qui la justifient (transfert, rang faible, oubli catastrophique, lois d’échelle), les implémentations minimales de chaque palier, et les cas — rares — où le from scratch est le bon choix.

Durée : 3 séances · Prérequis : L13, L25, L27, L28, L34, L36. Objectifs : parcourir l’escalade sur un cas réel avec des mesures à chaque palier ; implémenter LoRA et un affinage de tête ; quantifier l’oubli catastrophique ; estimer le coût et le délai de chaque palier ; reconnaître les situations qui justifient le from scratch.

Ce que vous saurez faire à la fin

Placer un problème sur l’escalade et justifier le palier de départ.
Mesurer, à chaque palier, qualité, coût, délai, risque — et décider de monter ou de s’arrêter.
Expliquer pourquoi LoRA marche (rang faible), pourquoi l’affinage oublie, pourquoi le pré-entraînement exige des lois d’échelle.
Rédiger le dossier « from scratch » : conditions, données, calcul, équipe, plan d’évaluation.

Fiche de cours · Définitions

Définitions

Définition (l’escalade). Suite ordonnée de solutions par coût, délai et risque croissants : (0) règles/heuristiques ; (1) modèle classique sur traits (régression, arbres) ; (2) modèle pré-entraîné utilisé tel quel (zero-shot, plongements + classifieur linéaire) ; (3) prompt engineering et few-shot ; (4) RAG et outils ; (5) affinage léger (LoRA, adaptateurs, tête, quelques couches) ; (6) affinage complet ; (7) pré-entraînement continu (continued pretraining) sur un domaine ; (8) pré-entraînement from scratch. Règle : on monte d’un palier seulement quand le banc d’essai (L32) prouve que le palier courant plafonne sous l’exigence.

Définition (apprentissage par transfert). Réutiliser les représentations d’un modèle entraîné sur une tâche source (grand corpus) pour une tâche cible (peu de données) : extraction de traits (encodeur gelé + tête), ou affinage (tout ou partie des poids).

Définition (affinage léger — PEFT). N’entraîner qu’une petite fraction des paramètres : LoRA (matrices de rang faible ajoutées aux projections), adaptateurs (petits MLP insérés), prefix/prompt tuning (vecteurs d’entrée appris), BitFit (biais seulement), gel de couches. QLoRA : LoRA sur un modèle de base quantifié en 4 bits.

Définition (oubli catastrophique). Perte des capacités antérieures lors de l’affinage sur une nouvelle tâche ; mesurée par la baisse sur un jeu général avant/après. Atténué par : petit pas, peu d’époques, mélange de données générales (rehearsal), régularisation vers les poids initiaux (L2-SP, EWC), PEFT.

Définition (pré-entraînement continu). Poursuivre le pré-entraînement (token suivant) d’un modèle existant sur un corpus de domaine (médical, juridique, code interne) avant l’affinage d’instruction ; coûte 10–100× moins qu’un from scratch pour un gain de domaine substantiel.

Définition (from scratch). Entraîner depuis une initialisation aléatoire : architecture, tokeniseur, corpus, recette d’optimisation, lois d’échelle, évaluation — tout est à concevoir. Justifié quand aucune base pré-entraînée ne couvre la modalité, la langue, la structure des données, ou les contraintes (licence, taille embarquée, souveraineté), et que données et calcul sont disponibles.

Définition (distillation). Entraîner un petit modèle (élève) à imiter les sorties (logits ou textes) d’un grand (maître) : garde la qualité à moindre coût d’inférence ; c’est un « from scratch » guidé.

Fiche de cours · Formules

Formules et ordres de grandeur

Palier	Données nécessaires	Calcul	Délai typique	Compétence	Risque principal
0. Règles	Aucune (expertise)	0	Heures–jours	Métier	Ne généralise pas ; maintenance des règles
1. Modèle classique	10²–10⁵ exemples étiquetés	CPU, minutes	Jours	ML de base	Traits à concevoir ; plafond sur données non structurées
2. Pré-entraîné tel quel	0–10² pour évaluer	Inférence	Heures	Intégration	Domaine hors distribution ; licence
3. Prompt / few-shot	10¹–10² exemples	Inférence	Jours	L28	Sensibilité, coût par requête, plafond
4. RAG / outils	Corpus + 10² questions annotées	Inférence + index	Semaines	L26	Rappel de la recherche
5. Affinage léger	10²–10⁴ exemples	1 GPU, heures	Semaines	Entraînement	Sur-apprentissage, oubli modéré, évaluation
6. Affinage complet	10⁴–10⁶	Plusieurs GPU, jours	Semaines–mois	Infra + entraînement	Oubli catastrophique, coût, reproductibilité
7. Pré-entraînement continu	10⁸–10¹⁰ tokens de domaine	8–64 GPU, semaines	Mois	Équipe	Dérive des capacités générales, données
8. From scratch	10¹⁰–10¹³ tokens	10²–10⁴ GPU, mois	6–18 mois	Équipe experte	Tout ; coût 10⁵–10⁸ €

LoRA : W′ = W₀ + BA, B ∈ ℝ^d×r, A ∈ ℝ^r×k, r ≪ min(d, k) ; paramètres r(d + k) au lieu de dk ; facteur d’échelle α/r ; A gaussien, B = 0 à l’initialisation

Coût d’affinage ≈ 6 × N_entraînés × D + 2 × N_gelés × D (passage avant sur tout, arrière sur la partie entraînée) — LoRA divise la mémoire des états d’optimiseur par ≈ 100, le temps par ≈ 1,5–2 seulement

Oubli : Δ_général = score_général(avant) − score_général(après) ; EWC : L = L_cible + (λ/2) Σ_i F_i(θ_i − θ*_i)² avec F la diagonale de Fisher

Pré-entraînement continu : mélanger p % de données générales (rehearsal, p ≈ 5–20 %) et réchauffer le pas (warmup) pour éviter le choc de distribution

From scratch (Chinchilla, L25) : pour N paramètres, D ≈ 20N tokens, C = 6ND FLOPs ; 1B → 20 G tokens, 1,2·10²⁰ FLOPs ≈ 140 h de H100 à 50 % de MFU

Distillation : L = (1 − λ)·CE(y, élève) + λ·T²·KL(softmax(z_maître/T) ‖ softmax(z_élève/T))

Règle de montée : monter au palier k + 1 ssi borne haute de l’IC(qualité au palier k, après effort raisonnable) < exigence, et coût(k + 1) ≤ valeur attendue du gain

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

Démonstrations à savoir refaire

Théorème 1 (pourquoi LoRA suffit : la mise à jour d’affinage est de rang faible effectif). Si l’affinage complet produit ΔW = W_fin − W₀ dont les valeurs singulières décroissent vite (σ_r+1 ≪ σ₁), alors la meilleure approximation de rang r (Eckart-Young, L10) capture ΔW avec une erreur σ_r+1 en norme spectrale, et LoRA peut la représenter exactement avec r(d + k) paramètres.

Eckart-Young : min_{rang ≤ r} ‖ΔW − M‖₂ = σ_r+1(ΔW), atteint par la SVD tronquée U_rΣ_rV_rᵀ = (U_rΣ_r)(V_rᵀ) = BA. L’observation empirique (Aghajanyan 2020 ; Hu 2021) est que la « dimension intrinsèque » des tâches d’affinage est faible : un modèle pré-entraîné a déjà les traits, l’affinage les re-pondère — une opération de rang faible. Pour d = k = 4 096, r = 16 : 131 k paramètres au lieu de 16,8 M par matrice (0,8 %). Conséquences : mémoire d’optimiseur ÷ 100 (on peut affiner un 70B sur un GPU en QLoRA), adaptateurs de quelques Mo échangeables à chaud (un modèle de base, N tâches), moins d’oubli (W₀ intact). Limite : si la tâche exige de nouvelles connaissances massives (langue nouvelle, domaine étranger), ΔW n’est plus de rang faible et LoRA plafonne — signal pour monter au palier 6 ou 7.

Théorème 2 (oubli catastrophique : un argument géométrique). Deux tâches A et B ont des minima θ*_A, θ*_B. Descendre sur L_B depuis θ*_A augmente L_A d’environ ½(θ − θ*_A)ᵀH_A(θ − θ*_A), H_A la hessienne de L_A ; l’oubli est grand dans les directions de forte courbure de A.

Taylor à l’ordre 2 de L_A autour de son minimum (gradient nul) : L_A(θ) ≈ L_A(θ*_A) + ½ΔθᵀH_AΔθ. Le gradient de L_B n’a aucune raison d’éviter les directions de grande courbure de A. Remèdes déduits : (1) EWC pénalise Δθ dans les directions importantes pour A (F ≈ H diagonale — l’information de Fisher) ; (2) le rehearsal ajoute L_A à l’objectif (on ne quitte pas le bassin de A) ; (3) PEFT restreint Δθ à un sous-espace de faible dimension, donc à une faible « masse » de courbure ; (4) petit pas et peu d’époques bornent ‖Δθ‖. Mesure obligatoire : un jeu général avant/après (MMLU, HellaSwag, ou vos propres tâches antérieures) — l’affinage qui gagne 10 points sur la cible et en perd 15 ailleurs n’est pas un progrès.

Théorème 3 (l’extraction de traits + classifieur linéaire est une borne inférieure de l’affinage). Le classifieur linéaire sur des plongements gelés atteint une exactitude ≤ celle du meilleur affinage de la même architecture ; l’écart mesure ce que l’affinage apporte.

L’affinage optimise sur un ensemble d’hypothèses qui contient (poids de l’encodeur figés, tête libre) le classifieur linéaire : son minimum de risque empirique est ≤ ; en généralisation, la relation tient sauf sur-apprentissage (petits jeux : le linéaire gagne souvent, car moins de paramètres). Méthode : toujours commencer par le linéaire sur plongements (minutes de calcul, aucune infra) ; si l’exigence est atteinte, s’arrêter (palier 2) ; sinon, l’écart avec quelques essais de LoRA dit si le palier 5 vaut l’effort.

Théorème 4 (le from scratch n’est rentable qu’au-delà d’un seuil de données et de calcul). Avec les lois d’échelle L(N, D) = E + A/N^α + B/D^β, un modèle from scratch de N paramètres entraîné sur vos D tokens ne dépasse un modèle pré-entraîné de N′ paramètres (perte L′ sur votre domaine après adaptation) que si E + A/N^α + B/D^β < L′ — ce qui exige D ≳ (B/(L′ − E − A/N^α))^1/β.

Inversion directe de la loi. Numériquement (constantes de Chinchilla) : pour battre une perte de 2,3 avec N = 1B, il faut D ≳ 10¹⁰ tokens de domaine de qualité — rarement disponibles hors web ; un pré-entraînement continu de 10⁹ tokens sur une base de 7B atteint généralement mieux, pour 1 % du calcul. Le from scratch se justifie surtout par des contraintes non capturées par la perte : modalité nouvelle (signaux de capteurs, protéines, séries industrielles), tokeniseur inadapté (langue, code chimique), taille embarquée (10 M de paramètres pour un microcontrôleur : aucune base n’existe à cette taille pour votre tâche), souveraineté ou licence.

01 / Parcourir l’escalade

Un cas réel simulé : classer des tickets techniques en 6 catégories, palier par palier

import numpy as np, re
rng = np.random.default_rng(0)
# Jeu : 1 200 tickets synthétiques mais structurés (vocabulaire par catégorie, bruit, formulations variées) ; exigence : macro-F1 ≥ 0,85 sur test
CAT = {"moteur": ["moteur", "surchauffe", "courant", "pwm", "vibration"], "lidar": ["lidar", "scan", "portée", "nuage", "rotation"], "batterie": ["batterie", "charge", "tension", "autonomie", "cellule"],
       "logiciel": ["plantage", "erreur", "version", "mise à jour", "logiciel"], "navigation": ["trajectoire", "carte", "localisation", "obstacle", "dérive"], "réseau": ["wifi", "connexion", "latence", "paquet", "réseau"]}
noms = list(CAT); COMMUN = ["le", "robot", "problème", "depuis", "hier", "signale", "après", "pendant", "mission", "fonctionne", "parfois", "souvent"]
def ticket(c):
    mots = rng.choice(CAT[c], rng.integers(1, 3)).tolist() + rng.choice(COMMUN, rng.integers(4, 9)).tolist()
    if rng.random() < 0.25: mots += rng.choice(CAT[rng.choice(noms)], 1).tolist()            # un mot d'une autre catégorie (ambiguïté)
    rng.shuffle(mots); return " ".join(mots)
y = rng.integers(0, 6, 1200); X = [ticket(noms[c]) for c in y]; tr, te = slice(0, 900), slice(900, None)
def macro_f1(y, yhat):
    f = []
    for c in range(6):
        tp = np.sum((y == c) & (yhat == c)); fp = np.sum((y != c) & (yhat == c)); fn = np.sum((y == c) & (yhat != c)); p = tp / max(1, tp + fp); r = tp / max(1, tp + fn); f.append(2 * p * r / max(1e-9, p + r))
    return np.mean(f)
def ic(f1, n=300): return 1.96 * np.sqrt(f1 * (1 - f1) / n)
# Palier 0 : règles (mots-clés) — délai : 1 heure
def regles(t):
    scores = [sum(m in t for m in CAT[c]) for c in noms]; return int(np.argmax(scores)) if max(scores) > 0 else 3
f0 = macro_f1(y[te], np.array([regles(t) for t in X[te]]))
# Palier 1 : modèle classique (sac de mots + régression logistique multinomiale) — délai : 1 jour
vocab = sorted({w for t in X for w in t.split()}); idx = {w: i for i, w in enumerate(vocab)}
def bow(t): v = np.zeros(len(vocab)); [v.__setitem__(idx[w], 1) for w in t.split()]; return v
B = np.array([bow(t) for t in X]); W = np.zeros((len(vocab), 6)); b = np.zeros(6)
for _ in range(300):
    z = B[tr] @ W + b; p = np.exp(z - z.max(1, keepdims=True)); p /= p.sum(1, keepdims=True); p[np.arange(900), y[tr]] -= 1
    W -= 0.5 * (B[tr].T @ p / 900 + 1e-3 * W); b -= 0.5 * p.mean(0)
f1_ = macro_f1(y[te], (B[te] @ W + b).argmax(1))
print(f"palier 0 règles         : macro-F1 {f0:.3f} ± {ic(f0):.3f}  (1 h, 0 €)")
print(f"palier 1 modèle classique: macro-F1 {f1_:.3f} ± {ic(f1_):.3f}  (1 jour, CPU)")
print(f"exigence 0,85 : {'atteinte au palier 1 — STOP' if f1_ - ic(f1_) >= 0.85 else 'non atteinte → envisager le palier 2/3 (plongements, few-shot)'}")
print("\nSur ce jeu, un modèle de 1 jour suffit ; un LLM aurait coûté 1 000× plus par requête pour un gain non prouvé. La décision se lit dans les IC, pas dans la mode.")

01 / Parcourir l’escalade

Paliers 2 et 5 : plongements gelés + linéaire, puis LoRA sur une couche — implémentés

import numpy as np
rng = np.random.default_rng(1)
# "Modèle pré-entraîné" simulé : un encodeur figé E qui produit des plongements de dimension 64 pour une tâche SOURCE (voisine) ;
# la tâche CIBLE a 6 classes dont la séparation n'est que partiellement alignée avec les traits sources.
d_in, d_emb, n_tr, n_te = 50, 64, 400, 400
E0 = rng.normal(0, 1 / np.sqrt(d_in), (d_in, d_emb))                                    # poids "pré-entraînés" (gelés)
centres = rng.normal(0, 1.2, (6, d_in)); Xtr = centres[rng.integers(0, 6, n_tr)] + rng.normal(0, 1, (n_tr, d_in)); ytr = np.argmin(((Xtr[:, None] - centres[None]) ** 2).sum(-1), 1)
Xte = centres[rng.integers(0, 6, n_te)] + rng.normal(0, 1, (n_te, d_in)); yte = np.argmin(((Xte[:, None] - centres[None]) ** 2).sum(-1), 1)
def relu(x): return np.maximum(0, x)
def entrainer_tete(H, y, Hte, yte, iters=300, lr=0.3):
    Wc = np.zeros((H.shape[1], 6)); bc = np.zeros(6)
    for _ in range(iters):
        z = H @ Wc + bc; p = np.exp(z - z.max(1, keepdims=True)); p /= p.sum(1, keepdims=True); p[np.arange(len(y)), y] -= 1
        Wc -= lr * (H.T @ p / len(y) + 1e-3 * Wc); bc -= lr * p.mean(0)
    return np.mean((Hte @ Wc + bc).argmax(1) == yte)
# Palier 2 : encodeur gelé + tête linéaire (Théorème 3 : borne inférieure)
acc2 = entrainer_tete(relu(Xtr @ E0), ytr, relu(Xte @ E0), yte)
# Palier 5 : LoRA sur E (rang r) + tête, entraînés ensemble par gradient (différences finies sur les 2 petites matrices, pour rester lisible)
def lora_acc(r, iters=120, lr=0.05):
    A = rng.normal(0, 0.05, (r, d_emb)); Bm = np.zeros((d_in, r)); Wc = np.zeros((d_emb, 6)); bc = np.zeros(6)
    def perte(A, Bm, Wc, bc):
        H = relu(Xtr @ (E0 + Bm @ A)); z = H @ Wc + bc; z = z - z.max(1, keepdims=True); return -np.mean(z[np.arange(n_tr), ytr] - np.log(np.exp(z).sum(1)))
    for _ in range(iters):
        H = relu(Xtr @ (E0 + Bm @ A)); z = H @ Wc + bc; p = np.exp(z - z.max(1, keepdims=True)); p /= p.sum(1, keepdims=True); p[np.arange(n_tr), ytr] -= 1
        gWc = H.T @ p / n_tr; gbc = p.mean(0); gH = (p @ Wc.T) * (H > 0) / n_tr                    # rétropropagation exacte jusqu'à E
        gE = Xtr.T @ gH; gB = gE @ A.T; gA = Bm.T @ gE                                             # chaîne à travers BA
        Wc -= lr * 6 * gWc; bc -= lr * 6 * gbc; Bm -= lr * gB; A -= lr * gA
    return np.mean((relu(Xte @ (E0 + Bm @ A)) @ Wc + bc).argmax(1) == yte), r * (d_in + d_emb)
print(f"palier 2  plongements gelés + linéaire : exactitude {acc2:.3f}  ({d_emb * 6 + 6} paramètres entraînés)")
for r in (2, 8, 32):
    a, npar = lora_acc(r); print(f"palier 5  LoRA rang {r:2d} + tête             : exactitude {a:.3f}  ({npar + d_emb * 6 + 6} paramètres entraînés, {npar / (d_in * d_emb):.1%} de l'encodeur)")
print("\nLecture : le rang 8 capture l'essentiel du gain (Théorème 1) ; l'écart palier 2 → 5 mesure ce que l'adaptation de l'encodeur apporte — s'il est faible, on s'arrête au palier 2.")

02 / Mesurer l’oubli

Oubli catastrophique et ses remèdes : une expérience contrôlée

import numpy as np
rng = np.random.default_rng(2)
# Un petit MLP appris sur la tâche A (générale), puis affiné sur la tâche B (cible) : mesurer A avant/après, avec 4 stratégies
d, h = 20, 64
def tache(seed, n):
    r = np.random.default_rng(seed); w = r.normal(0, 1, d); X = r.normal(0, 1, (n, d)); return X, ((X @ w + 0.3 * r.normal(0, 1, n)) > 0).astype(int)
XA, yA = tache(10, 1500); XB, yB = tache(11, 300); XAt, yAt = tache(12, 1000); XBt, yBt = tache(13, 1000)
XAt, yAt = tache(10, 2500)[0][1500:], tache(10, 2500)[1][1500:]; XBt, yBt = tache(11, 1300)[0][300:], tache(11, 1300)[1][300:]   # tests : mêmes tâches, autres exemples
def init(): return [rng.normal(0, 1 / np.sqrt(d), (d, h)), np.zeros(h), rng.normal(0, 1 / np.sqrt(h), (h, 1)), np.zeros(1)]
def avant(P, X): H = np.maximum(0, X @ P[0] + P[1]); return H, 1 / (1 + np.exp(-(H @ P[2] + P[3]))).ravel()
def grad(P, X, y):
    H, p = avant(P, X); g = (p - y)[:, None] / len(y); gW2 = H.T @ g; gb2 = g.sum(0); gH = (g @ P[2].T) * (H > 0); return [X.T @ gH, gH.sum(0), gW2, gb2]
def acc(P, X, y): return np.mean((avant(P, X)[1] > 0.5) == y)
def entrainer(P, X, y, iters, lr, reg=None, lam=0.0, melange=None):
    for _ in range(iters):
        g = grad(P, X, y)
        if melange is not None: gm = grad(P, *melange); g = [a + b for a, b in zip(g, gm)]          # rehearsal : gradient de A ajouté
        for i in range(4):
            pen = lam * reg[1][i] * (P[i] - reg[0][i]) if reg is not None else 0                      # EWC : λ F (θ − θ*)
            P[i] = P[i] - lr * (g[i] + pen)
    return P
PA = entrainer(init(), XA, yA, 400, 0.5); print(f"après tâche A : A {acc(PA, XAt, yAt):.3f}, B {acc(PA, XBt, yBt):.3f}")
F = [g ** 2 * len(yA) for g in grad(PA, XA, yA)]                                                   # Fisher diagonale approx. (gradient² par exemple, moyenné)
strategies = {"affinage complet (lr 0,5, 300 it)": dict(iters=300, lr=0.5), "petit pas, peu d'itérations": dict(iters=60, lr=0.1), "EWC (λ = 5)": dict(iters=300, lr=0.5, reg=(PA, F), lam=5.0), "rehearsal 20 % de A": dict(iters=300, lr=0.5, melange=(XA[:600], yA[:600]))}
print(f"\n{'stratégie':36s} {'A après':>8s} {'B après':>8s} {'oubli':>6s}")
for nom, kw in strategies.items():
    P = entrainer([p.copy() for p in PA], XB, yB, **kw); print(f"{nom:36s} {acc(P, XAt, yAt):8.3f} {acc(P, XBt, yBt):8.3f} {acc(PA, XAt, yAt) - acc(P, XAt, yAt):6.3f}")
print("\nL'affinage complet gagne B et détruit A ; les remèdes (petit pas, EWC, rehearsal) gardent A à ±2 points pour un B presque aussi bon. Sans mesure de A, personne ne l'aurait su.")

03 / Décider

La règle de montée, palier par palier : limites, contraintes, avantages

Palier	Avantages	Limites	Contraintes	Signal pour monter
0. Règles	Transparent, immédiat, sans données, débogable	Fragile aux formulations ; explosion combinatoire des cas	Expertise disponible	> 30 règles, précision qui stagne, cas non couverts fréquents
1. Classique	Rapide, peu de calcul, interprétable (coefficients, arbres), robuste	Traits à concevoir ; plafond sur texte/image bruts	10²+ exemples annotés	Courbe d’apprentissage plate sous l’exigence ; traits épuisés
2. Pré-entraîné tel quel	Zéro entraînement ; qualité générale élevée ; plongements universels	Hors domaine ; pas de contrôle du format ; licence	Inférence disponible	Linéaire sur plongements sous l’exigence
3. Prompt/few-shot	Itération en minutes ; pas d’infra d’entraînement	Plafond, sensibilité, coût par requête, latence	Banc d’essai	Plateau après 10 itérations mesurées ; coût/latence hors SLO
4. RAG/outils	Connaissances privées, à jour, citables	Rappel de la recherche ; complexité	Corpus, index, évaluation	Rappel > 0,9 mais qualité sous l’exigence → le modèle est la limite
5. Affinage léger	Format et style fiables, latence ↓ (prompt court), adaptateurs ; 1 GPU	Connaissances nouvelles limitées (rang faible) ; sur-apprentissage	10²–10⁴ exemples de qualité, banc d’oubli	Rang ↑ sans gain ; domaine trop éloigné
6. Affinage complet	Capacité maximale d’adaptation	Oubli, coût, infra multi-GPU, reproductibilité	10⁴+ exemples, équipe	Vocabulaire/domaine absents de la base
7. Pré-entraînement continu	Domaine profond pour 1 % du from scratch	Dérive des capacités générales ; données de domaine massives	10⁹+ tokens, cluster	Tokeniseur inadapté ; modalité absente
8. From scratch	Contrôle total (données, licence, taille, modalité)	Coût, délai, risque ; expertise rare	Données massives, calcul, équipe, lois d’échelle	— (dernier palier)

03 / Décider

Le dossier « from scratch » : les conditions à remplir, et l’estimation du coût

import numpy as np
# Estimation d'un pré-entraînement from scratch : taille, tokens, calcul, temps, coût, et comparaison avec le pré-entraînement continu
def from_scratch(N, D=None, mfu=0.45, flops_gpu=990e12, prix_gpu_h=3.0, n_gpu=64):
    D = D or 20 * N; C = 6 * N * D; heures = C / (flops_gpu * mfu) / 3600; return D, C, heures / n_gpu, heures * prix_gpu_h
def continu(N_base, D_domaine, mfu=0.45, flops_gpu=990e12, prix_gpu_h=3.0, n_gpu=8):
    C = 6 * N_base * D_domaine; heures = C / (flops_gpu * mfu) / 3600; return C, heures / n_gpu, heures * prix_gpu_h
print(f"{'option':44s} {'tokens':>9s} {'FLOPs':>9s} {'durée':>10s} {'coût GPU':>10s}")
for N in (125e6, 1e9, 7e9):
    D, C, jours_h, cout = from_scratch(N); print(f"{'from scratch ' + f'{N/1e9:.3g}B':44s} {D:9.1e} {C:9.1e} {jours_h/24:7.1f} j {cout:9.0f} €")
for Dd in (1e9, 1e10):
    C, jours_h, cout = continu(7e9, Dd); print(f"{'pré-entraînement continu 7B sur ' + f'{Dd:.0e} tokens':44s} {Dd:9.1e} {C:9.1e} {jours_h/24:7.1f} j {cout:9.0f} €")
print("\nÀ ajouter au coût GPU : données (collecte, nettoyage : souvent > le calcul), équipe (3–10 personnes × 6–18 mois), évaluation, essais ratés (×2–3), infra.")
print("\nCONDITIONS pour ouvrir un dossier from scratch (toutes nécessaires) :")
for c in ("aucun modèle pré-entraîné ne couvre la modalité / la langue / la structure (vérifié par une recherche sérieuse et des essais aux paliers 2–7)",
          "des données propres en quantité suffisante (Théorème 4 : D ≳ 10⁹–10¹⁰ tokens de qualité) avec les droits",
          "le calcul et le budget (× 3 pour les essais) et une équipe qui a déjà entraîné à cette échelle",
          "un plan d'évaluation qui prouvera le gain sur VOTRE tâche contre le meilleur palier inférieur (L32)",
          "une raison qui ne disparaîtra pas dans 12 mois (contrainte embarquée, souveraineté, licence) — pas seulement la performance"):
    print(" •", c)

Les cas légitimes existent : modèles de fondation pour les séries de capteurs industriels, la chimie, la génomique, les signaux radar, un micro-modèle de 5 M de paramètres pour un microcontrôleur (L18), une langue sans base pré-entraînée, ou un acteur souverain. Dans ces cas, la partie K entière est le cahier des charges — lois d’échelle (L25), données (L36), infra (L33), évaluation (L32), MLOps (L38).

04 / Articles

Les articles à lire

Article	Contribution	À retenir
Pan & Yang, A Survey on Transfer Learning, IEEE TKDE 2010	Cadre du transfert	Quand le transfert aide, quand il nuit (transfert négatif)
Howard & Ruder, Universal Language Model Fine-tuning (ULMFiT), ACL 2018 — 1801.06146	Affinage progressif, pas différencié par couche	Les recettes anti-oubli avant les LLM
Aghajanyan et al., Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning, ACL 2021 — 2012.13255 ; Hu et al., LoRA, 2021 — 2106.09685	Dimension intrinsèque faible ; adaptation de rang faible	Théorème 1
Dettmers et al., QLoRA, 2023 — 2305.14314	LoRA sur base 4 bits	Affiner un 65B sur un GPU
Kirkpatrick et al., Overcoming catastrophic forgetting in neural networks (EWC), PNAS 2017 — 1612.00796	Pénalité de Fisher	Théorème 2 ; mesurer l’oubli
Luo et al., An Empirical Study of Catastrophic Forgetting in LLMs During Continual Fine-tuning, 2023 — 2308.08747	L’oubli croît avec la taille et l’affinage	Jeu général avant/après, toujours
Gururangan et al., Don’t Stop Pretraining, ACL 2020 — 2004.10964	Pré-entraînement continu de domaine et de tâche	Palier 7 : gains solides pour peu de calcul
Hinton, Vinyals & Dean, Distilling the Knowledge in a Neural Network, 2015 — 1503.02531	Distillation par logits à température	Petit modèle guidé plutôt que from scratch aveugle
Hoffmann et al., Chinchilla, 2022 (L25)	Lois d’échelle	Théorème 4 : le seuil du from scratch
Biderman et al., Pythia, ICML 2023 — 2304.01373 ; Groeneveld et al., OLMo, 2024 — 2402.00838	Recettes de pré-entraînement entièrement ouvertes	Ce qu’un from scratch exige, documenté de bout en bout
Zhou et al., LIMA, 2023 (L36)	Peu d’exemples de qualité pour l’affinage d’instruction	Le palier 5 avec 1 000 exemples
Bommasani et al., 2021 (L34)	Modèles de fondation	Pourquoi l’escalade commence par « réutiliser »

TP guidé

TP — L’escalade complète sur votre tâche (8 h, étalées)

Banc d’essai d’abord. Tâche réelle avec 300 cas de test annotés (L36), métrique et exigence (L32), plus un jeu « général » pour mesurer l’oubli (si LLM : 200 questions générales).
Paliers 0–1. Règles (1 h) puis modèle classique (scikit-learn : TF-IDF + régression logistique / gradient boosting) ; courbe d’apprentissage sur 10–100 % des données ; IC.
Palier 2. Plongements d’un encodeur pré-entraîné (sentence-transformers, DINOv2 pour images) + régression logistique : 20 minutes, souvent le meilleur rapport qualité/effort.
Paliers 3–4. LLM en few-shot (banc de prompts L28) ; RAG si des connaissances externes sont nécessaires (L26).
Palier 5. LoRA (PEFT/TRL) sur un modèle 1–8B avec 500–2 000 exemples ; r ∈ {4, 16, 64} ; 3 graines ; mesurer cible ET général (oubli) ; comparer QLoRA.
Décision. Tableau palier × (qualité IC, coût, délai, latence, oubli) ; identifier le palier d’arrêt selon la règle de montée ; rédiger l’ADR (L34) et, si pertinent, le dossier « pourquoi pas from scratch » (ou « pourquoi from scratch », avec l’estimation de coût).

Exercices

Exercices auto-corrigés

Exercice 1 — LoRA : paramètres et approximation de rang faible

Écrivez params_lora(d, k, r), fraction_lora(d, k, r), et meilleure_approx_rang(M, r) (SVD tronquée) ; vérifiez Eckart-Young sur une matrice ΔW construite de rang effectif 4 + bruit : l’erreur relative chute jusqu’à r = 4 puis plafonne.

Correction

def params_lora(d, k, r): return r * (d + k)
def fraction_lora(d, k, r): return r * (d + k) / (d * k)
def meilleure_approx_rang(M, r):
    U, S, Vt = np.linalg.svd(M, full_matrices=False); return (U[:, :r] * S[:r]) @ Vt[:r]

Exercice 2 — La règle de montée

Écrivez palier_suivant(resultats, exigence, budget_restant) : resultats = liste ordonnée de (palier, f1, n_test, cout) déjà mesurés ; renvoie le palier courant s’il satisfait l’exigence en borne basse de l’IC (±1,96√(f1(1−f1)/n)), sinon le palier suivant si son coût estimé (dict) tient dans le budget, sinon "arrêt : exigence inatteignable dans le budget".

Correction

def palier_suivant(resultats, exigence, budget_restant):
    p, f1, n, _ = resultats[-1]; borne = f1 - 1.96 * np.sqrt(f1 * (1 - f1) / n)
    if borne >= exigence: return p
    if p + 1 in COUTS and COUTS[p + 1] <= budget_restant: return p + 1
    return "arrêt : exigence inatteignable dans le budget"

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Mesurer l’oubli et choisir le compromis

Écrivez oubli(avant, apres) (dict de scores généraux → baisse moyenne) et meilleur_compromis(strategies, poids_oubli) : strategies = {nom: (score_cible, oubli)} ; renvoie le nom qui maximise score_cible − poids_oubli × oubli. Vérifiez qu’avec un fort poids d’oubli, l’affinage complet n’est jamais choisi.

Correction

def oubli(avant, apres): return sum(avant[k] - apres[k] for k in avant) / len(avant)
def meilleur_compromis(strategies, poids_oubli): return max(strategies, key=lambda n: strategies[n][0] - poids_oubli * strategies[n][1])

Exercice 4 — Seuil du from scratch (Théorème 4)

Avec L(N, D) = E + A/N^α + B/D^β (E = 1,69, A = 406,4, B = 410,7, α = 0,34, β = 0,28), écrivez tokens_necessaires(N, L_cible) (D minimal pour atteindre L_cible avec N paramètres, ou None si impossible) et cout_flops(N, D) = 6ND. Comparez : battre L = 2,3 avec 1B from scratch vs pré-entraînement continu de 10⁹ tokens sur 7B.

Correction

def tokens_necessaires(N, L_cible):
    reste = L_cible - E - A / N ** alpha
    if reste <= 0: return None
    return (B / reste) ** (1 / beta)
def cout_flops(N, D): return 6 * N * D

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Une start-up veut « son propre LLM » pour un assistant juridique en français. Rédiger l’avis d’un ingénieur.

Correction. Le besoin réel est un assistant qui répond juste, avec sources, en français juridique. Escalade : (2) tester 3 modèles ouverts/API en zero-shot sur 300 questions annotées par des juristes (une semaine) ; (4) RAG sur le corpus juridique (codes, jurisprudence, notes internes) — c’est presque toujours le palier décisif ici : l’information est vaste, à jour, citable ; (5) LoRA sur 2 000 paires (question, réponse citée) pour le format, le ton et les refus ; (7) pré-entraînement continu sur 10⁹ tokens juridiques français si le vocabulaire manque (mesuré par la perplexité et le banc) ; (8) from scratch : non — des bases françaises existent, le corpus juridique public est de l’ordre de 10⁹–10¹⁰ tokens (insuffisant pour battre une base de 7B, Théorème 4), le coût (10⁶–10⁷ €) et le délai (12 mois) sont incompatibles, et la performance viendra du RAG et de l’évaluation, pas des poids. Livrer un ADR avec ces mesures ; « son propre LLM » devient « son propre adaptateur LoRA et son propre index », ce qui est défendable et différenciant.

Exercice 2. Après LoRA (r = 64) sur 5 000 exemples, la qualité cible plafonne à 0,78 pour une exigence de 0,85, et le rang n’y change rien. Que conclure et que faire ?

Correction. Le plateau indépendant du rang indique que ΔW nécessaire n’est pas de rang faible ou que la limite n’est pas dans les poids : vérifier d’abord (a) le bruit d’étiquettes du test (Théorème 4 de L36 : un plafond de 0,78 peut être un plafond d’annotation), (b) l’analyse d’erreurs (les échecs sont-ils des connaissances absentes → RAG/pré-entraînement continu, ou des ambiguïtés → consigne), (c) la courbe d’apprentissage (les 5 000 exemples sont-ils saturés ?). Si la limite est bien le modèle : affinage complet avec rehearsal et mesure d’oubli (palier 6), ou base plus grande avec LoRA (souvent plus efficace que le palier 6 sur une petite base), ou pré-entraînement continu si le domaine est étranger. Chaque option se chiffre (coût, délai) avant d’être lancée ; l’exigence peut aussi être renégociée si 0,85 n’a pas de justification métier mesurée.

Exercice 3. Dans quels cas un modèle de 3 M de paramètres entraîné from scratch est-il le bon choix, et comment procéder ?

Correction. Cas : détection d’anomalies sur des séries de capteurs à 1 kHz dans un microcontrôleur (L18) avec 100 Ko de mémoire, sans réseau ; reconnaissance de 20 commandes vocales embarquée ; classification de gestes IMU. Aucun modèle pré-entraîné n’existe pour cette modalité à cette taille, et la distillation d’un grand modèle est possible mais pas nécessaire. Procédure : (1) données réelles du capteur (L36 : sessions, séparation par appareil), augmentation (bruit, décalages) ; (2) architecture à biais adapté (TCN causal, petit CNN 1D, L31), taille dimensionnée par la mémoire et le WCET ; (3) entraînement sur PC (minutes), validation par groupe ; (4) quantification int8, export (TFLite Micro, CMSIS-NN), test sur cible (latence, mémoire) ; (5) évaluation par condition (bruit, températures, appareils) ; (6) monitoring : télémétrie agrégée et mise à jour OTA signée (L35). Ici le from scratch est le palier 1 en pratique — la règle « ne pas partir de zéro » s’applique aux modèles de fondation, pas aux petits modèles spécialisés.

Vérification

Le palier « plongements gelés + régression logistique » donne 0,83 [0,80 ; 0,86] pour une exigence de 0,85. Prochaine étape ?

Deux questions supplémentaires

1. Pourquoi LoRA marche-t-il ? La mise à jour d’affinage est de rang faible effectif ; une SVD tronquée la capture (Théorème 1).

2. Que mesurer obligatoirement après un affinage ? Un jeu général avant/après : l’oubli catastrophique (Théorème 2).

Référence

Les mots à retenir

Mot	Définition
Escalade	Règles → classique → pré-entraîné → prompt → RAG → PEFT → complet → continu → from scratch.
Règle de montée	Monter d’un palier ssi la borne basse de l’IC est sous l’exigence et le coût tient.
Transfert	Réutiliser les représentations ; linéaire sur plongements = borne inférieure.
LoRA / PEFT	Adaptation de rang faible ; 1 % des poids ; adaptateurs échangeables.
Oubli catastrophique	Perte des capacités antérieures ; EWC, rehearsal, petit pas ; à mesurer.
Pré-entraînement continu	Domaine profond pour 1 % du from scratch.
From scratch	Justifié par modalité, taille embarquée, souveraineté ; jamais par la seule performance.
Distillation	Petit modèle guidé par un grand.

Suite

Vous savez quoi construire. Reste comment le construire ensemble, proprement, durablement.

Chapitre suivant : les bonnes pratiques — CRISP-ML(Q), MLOps, AIOps — le cycle de vie, l’assurance qualité, l’automatisation, et les niveaux de maturité.

← L36 Sommaire L38 : CRISP-ML(Q), MLOps, AIOps →