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

Le Transformer en profondeur : de l’équation à l’implémentation, et aux articles qui l’ont fait.

Le module L15 a introduit l’attention. Ici, on démonte entièrement la machine : chaque matrice, chaque gradient, le cache KV, les variantes (encodeur, décodeur, encodeur-décodeur, MQA/GQA, RoPE, FlashAttention), les lois d’échelle, et ce que disent les articles fondateurs — lus avec la méthode de L24. Vue informatique (complexité, mémoire, implémentation) et vue mathématique (formes quadratiques, softmax, gradients, invariances).

Durée : 4 séances · Prérequis : L10, L14, L15, L24. Objectifs : implémenter un transformer décodeur complet en NumPy avec rétropropagation manuelle ; expliquer chaque choix architectural par une raison mathématique ou matérielle ; lire « Attention Is All You Need », les lois d’échelle et FlashAttention ; dimensionner un modèle.

Ce que vous saurez faire à la fin

Écrire un bloc transformer (attention multi-têtes causale, MLP, LayerNorm, résiduel) et son gradient, et l’entraîner.
Expliquer pourquoi √d_k, pourquoi le pré-LN, pourquoi le cache KV, pourquoi GQA, pourquoi FlashAttention.
Calculer paramètres, FLOPs, mémoire d’activation et de cache pour un modèle donné.
Résumer dix articles clés avec leur contribution et leurs limites.

Fiche de cours · Définitions

Définitions à connaître

Définition (séquence, contexte, causalité). Entrée : une suite de n tokens x₁…x_n ∈ V. Le contexte d’une position t est x_≤t (décodeur causal) ou toute la séquence (encodeur). Un modèle est causal si sa sortie à la position t ne dépend que de x_≤t.

Définition (tête d’attention). Paramètres W_Q, W_K ∈ ℝ^d×d_k, W_V ∈ ℝ^d×d_v. Pour X ∈ ℝ^n×d : Q = XW_Q, K = XW_K, V = XW_V, S = QKᵀ/√d_k + M (masque), A = softmax_lignes(S), sortie AV ∈ ℝ^n×d_v. Multi-têtes : h têtes concaténées puis projetées par W_O ∈ ℝ^hd_v×d.

Définition (bloc, pré-LN, post-LN). Post-LN (article original) : x ← LN(x + Attn(x)) ; x ← LN(x + MLP(x)). Pré-LN (pratique moderne) : x ← x + Attn(LN(x)) ; x ← x + MLP(LN(x)). Le flux résiduel x traverse tout le réseau sans normalisation en pré-LN : gradients plus stables.

Définition (cache KV). En génération autorégressive, les K et V des positions passées ne changent pas : on les mémorise (n × L × h × d_k × 2 valeurs) pour ne calculer, à chaque nouveau token, que sa requête et son attention sur le cache : coût par token O(n·d) au lieu de O(n²·d).

Définition (MQA, GQA). Multi-Query Attention : une seule paire (K, V) partagée par toutes les têtes ; Grouped-Query : g groupes de têtes partagent leurs K, V. Réduit le cache KV d’un facteur h (MQA) ou h/g (GQA) — la mémoire, pas le calcul, limite l’inférence.

Définition (RoPE). Encodage positionnel rotatif : q et k sont tournés, par paires de dimensions, d’un angle proportionnel à la position (fréquences géométriques) ; le produit scalaire q_tᵀk_s ne dépend que de t − s.

Définition (lois d’échelle). Relations empiriques perte ≈ f(N paramètres, D tokens, C calcul) en lois de puissance ; Chinchilla : à C fixé, N et D doivent croître ensemble, D ≈ 20N.

Fiche de cours · Formules

Formules : calcul, mémoire, gradients

Paramètres par bloc : attention 4d² (Q, K, V, O) + MLP 2·d·d_ff (= 8d² si d_ff = 4d) + LN 4d ≈ 12d² ; total ≈ 12Ld² + 2Vd (embeddings entrée/sortie, souvent liés)

FLOPs par token (passage avant) ≈ 2N + 2·L·n·d (le second terme : attention, quadratique en n) ; entraînement ≈ 3× (avant + arrière) ⇒ 6N·D FLOPs

Cache KV (float16) = 2 · L · n · h_kv · d_k · 2 octets — LLaMA-2 70B (L = 80, h_kv = 8, d_k = 128), n = 4 096 : 1,3 Go par séquence

Mémoire d’activation d’entraînement ≈ n·d·L·(34 + 5·h·n/d) octets par séquence (Korthikanti 2022) — l’attention matérialisée domine pour n grand

Gradient de l’attention (une tête, sans masque) : ∂ℓ/∂V = Aᵀ G ; ∂ℓ/∂A = G Vᵀ ; ∂ℓ/∂S = A ⊙ (∂ℓ/∂A − rowsum(∂ℓ/∂A ⊙ A)) ; ∂ℓ/∂Q = (∂ℓ/∂S) K/√d_k ; ∂ℓ/∂K = (∂ℓ/∂S)ᵀ Q/√d_k G = gradient sur la sortie AV ; la formule de ∂S est le jacobien du softmax ligne par ligne

LayerNorm : y = (x − μ)/σ ; ∂ℓ/∂x = (1/σ)·[g − mean(g) − y·mean(g ⊙ y)] avec g = γ ⊙ ∂ℓ/∂y

RoPE : q_t = R_Θ,t q, avec R_Θ,t = diag(R(tθ₁), …, R(tθ_d/2)), θ_i = 10000^−2i/d ⇒ q_tᵀk_s = qᵀR_Θ,s−tk

Loi de Chinchilla : L(N, D) ≈ E + A/N^α + B/D^β avec α ≈ 0,34, β ≈ 0,28 ; optimum à C = 6ND fixé : N ∝ C^0,5, D ∝ C^0,5

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

Démonstrations à savoir refaire

Théorème 1 (jacobien du softmax et gradient de l’attention). Pour a = softmax(s) (une ligne), ∂a_i/∂s_j = a_i(δ_ij − a_j) ; donc pour un gradient amont g = ∂ℓ/∂a, ∂ℓ/∂s = a ⊙ (g − ⟨g, a⟩).

a_i = e^s_i/Z, Z = Σ_k e^s_k. ∂a_i/∂s_j = (δ_ije^s_iZ − e^s_ie^s_j)/Z² = a_iδ_ij − a_ia_j. Règle de la chaîne : ∂ℓ/∂s_j = Σ_i g_ia_i(δ_ij − a_j) = a_jg_j − a_jΣ_ig_ia_i = a_j(g_j − ⟨g, a⟩). Le terme ⟨g, a⟩ est ce que FlashAttention recalcule à rebours à partir de la sortie O et de son gradient dO : ⟨g, a⟩ = rowsum(dO ⊙ O) — ce qui évite de stocker A (n²). Le reste suit par linéarité : ∂ℓ/∂Q = (∂ℓ/∂S)K/√d_k, etc.

Théorème 2 (le cache KV est exact). En décodage causal, la sortie de la position t calculée avec le cache est identique à celle du passage complet sur x_≤t.

K et V à la couche ℓ pour la position s ≤ t sont des fonctions de h_ℓ−1,s, qui par causalité (L15, Théorème 4) ne dépend que de x_≤s — donc inchangé quand on ajoute x_t+1. La requête q_t attend sur K_≤t, V_≤t : exactement ce que contient le cache. Par récurrence sur les couches, toute la pile est identique. Le coût de génération de n tokens passe de Σ_t O(t²d) = O(n³d) (recalcul complet) à Σ_t O(td) = O(n²d).

Théorème 3 (RoPE encode la position relative). Avec q_t = R_tq et k_s = R_sk où R_t est une rotation par blocs 2×2 d’angles tθ_i, on a q_tᵀk_s = qᵀR_s−tk.

Les rotations d’un même bloc commutent et R_tᵀ = R_−t ; R_−tR_s = R_s−t (angles additifs). Donc q_tᵀk_s = qᵀR_tᵀR_sk = qᵀR_s−tk. Le score ne dépend que de s − t : le modèle généralise mieux à des positions absolues non vues, et l’extension de contexte (interpolation des fréquences) devient possible. Les fréquences géométriques donnent des « horloges » de périodes variées, comme l’encodage sinusoïdal (L15, Théorème 3), mais appliquées multiplicativement à q et k plutôt qu’ajoutées à x.

Théorème 4 (FlashAttention : softmax par blocs). Le softmax d’une ligne peut être calculé par blocs en maintenant (m, ℓ) = (max courant, somme courante des exponentielles) : pour un nouveau bloc de scores s_b, m′ = max(m, max s_b), ℓ′ = e^m−m′ℓ + Σ e^s_b−m′, et la sortie partielle O′ = e^m−m′O + Σ e^s_b−m′v_b ; à la fin O/ℓ est exact.

softmax(s)·V = Σ_j e^s_j−m*v_j / Σ_j e^s_j−m* pour tout m* (invariance par translation du softmax). On accumule numérateur et dénominateur avec un m courant, et l’on renormalise par e^m−m′ quand le max augmente : chaque terme e^s_j−m devient e^s_j−m′ exactement. Aucune matrice n×n n’est matérialisée : mémoire O(n) pour l’attention, et les blocs tiennent dans la SRAM du GPU (bien plus rapide que la HBM) — d’où une accélération 2–4× malgré un léger surcoût de calcul (Dao et al. 2022).

01 / Implémenter

Une tête d’attention et son gradient, vérifiés par différences finies

import numpy as np
rng = np.random.default_rng(0)
def softmax(S):
    S = S - S.max(-1, keepdims=True); E = np.exp(S); return E / E.sum(-1, keepdims=True)
def attention_avant(X, Wq, Wk, Wv, causal=True):
    Q, K, V = X @ Wq, X @ Wk, X @ Wv; dk = Q.shape[-1]
    S = Q @ K.T / np.sqrt(dk)
    if causal: S = S + np.triu(np.full_like(S, -1e9), 1)       # masque : -inf au-dessus de la diagonale
    A = softmax(S); return A @ V, (X, Q, K, V, A)
def attention_arriere(G, cache, Wq, Wk, Wv):
    X, Q, K, V, A = cache; dk = Q.shape[-1]
    dV = A.T @ G; dA = G @ V.T
    dS = A * (dA - (dA * A).sum(-1, keepdims=True))         # jacobien du softmax (Théorème 1)
    dQ = dS @ K / np.sqrt(dk); dK = dS.T @ Q / np.sqrt(dk)
    dWq, dWk, dWv = X.T @ dQ, X.T @ dK, X.T @ dV
    dX = dQ @ Wq.T + dK @ Wk.T + dV @ Wv.T
    return dX, dWq, dWk, dWv
n, d, dk = 5, 8, 4
X = rng.normal(0, 1, (n, d)); Wq, Wk, Wv = (rng.normal(0, 0.3, (d, dk)) for _ in range(3))
O, cache = attention_avant(X, Wq, Wk, Wv)
G = rng.normal(0, 1, O.shape)                                 # gradient "amont" arbitraire : perte = somme(G * O)
dX, dWq, dWk, dWv = attention_arriere(G, cache, Wq, Wk, Wv)
def perte(Wq_): return (G * attention_avant(X, Wq_, Wk, Wv)[0]).sum()
num = np.zeros_like(Wq); eps = 1e-5
for i in range(d):
    for j in range(dk):
        E = np.zeros_like(Wq); E[i, j] = eps; num[i, j] = (perte(Wq + E) - perte(Wq - E)) / (2 * eps)
print("erreur relative gradient dWq (analytique vs différences finies) :", np.abs(num - dWq).max() / np.abs(num).max())
print("causalité : la sortie 2 ne regarde pas la position 4 →", np.allclose(cache[4][2, 3:], 0))

Une erreur relative < 10⁻⁶ valide la dérivation. C’est la première chose à faire avant tout entraînement : un gradient faux entraîne quand même « un peu », et l’on perd des jours.

01 / Implémenter

Le bloc complet : multi-têtes, LayerNorm, MLP, résiduel — et un mini-GPT qui apprend

import numpy as np
rng = np.random.default_rng(1)
# Mini-GPT en NumPy avec gradients "manuels" : chaque couche a avant() et arriere(). Entraîné sur un langage jouet.
class Lineaire:
    def __init__(s, i, o, scale=None): s.W = rng.normal(0, scale or (1 / np.sqrt(i)), (i, o)); s.b = np.zeros(o); s.p = [s.W, s.b]
    def avant(s, x): s.x = x; return x @ s.W + s.b
    def arriere(s, g): s.dW = s.x.reshape(-1, s.x.shape[-1]).T @ g.reshape(-1, g.shape[-1]); s.db = g.reshape(-1, g.shape[-1]).sum(0); s.dp = [s.dW, s.db]; return g @ s.W.T
class LayerNorm:
    def __init__(s, d): s.g = np.ones(d); s.b = np.zeros(d); s.p = [s.g, s.b]
    def avant(s, x): s.mu = x.mean(-1, keepdims=True); s.sig = np.sqrt(x.var(-1, keepdims=True) + 1e-5); s.y = (x - s.mu) / s.sig; return s.g * s.y + s.b
    def arriere(s, g): s.dg = (g * s.y).reshape(-1, g.shape[-1]).sum(0); s.db = g.reshape(-1, g.shape[-1]).sum(0); s.dp = [s.dg, s.db]; gy = g * s.g; return (gy - gy.mean(-1, keepdims=True) - s.y * (gy * s.y).mean(-1, keepdims=True)) / s.sig
def softmax(S): S = S - S.max(-1, keepdims=True); E = np.exp(S); return E / E.sum(-1, keepdims=True)
class Attention:                                  # multi-têtes causale ; x : (n, d)
    def __init__(s, d, h): s.h, s.dk = h, d // h; s.qkv = Lineaire(d, 3 * d); s.o = Lineaire(d, d); s.p = s.qkv.p + s.o.p
    def avant(s, x):
        n, d = x.shape; qkv = s.qkv.avant(x); Q, K, V = [m.reshape(n, s.h, s.dk).transpose(1, 0, 2) for m in np.split(qkv, 3, -1)]
        S = Q @ K.transpose(0, 2, 1) / np.sqrt(s.dk) + np.triu(np.full((n, n), -1e9), 1); A = softmax(S); Y = A @ V
        s.c = (Q, K, V, A); return s.o.avant(Y.transpose(1, 0, 2).reshape(n, d))
    def arriere(s, g):
        Q, K, V, A = s.c; h, n, dk = Q.shape; G = s.o.arriere(g).reshape(n, h, dk).transpose(1, 0, 2)
        dV = A.transpose(0, 2, 1) @ G; dA = G @ V.transpose(0, 2, 1); dS = A * (dA - (dA * A).sum(-1, keepdims=True))
        dQ = dS @ K / np.sqrt(dk); dK = dS.transpose(0, 2, 1) @ Q / np.sqrt(dk)
        dqkv = np.concatenate([m.transpose(1, 0, 2).reshape(n, h * dk) for m in (dQ, dK, dV)], -1)
        out = s.qkv.arriere(dqkv); s.dp = s.qkv.dp + s.o.dp; return out
class MLP:
    def __init__(s, d): s.l1 = Lineaire(d, 4 * d); s.l2 = Lineaire(4 * d, d); s.p = s.l1.p + s.l2.p
    def avant(s, x): s.z = s.l1.avant(x); return s.l2.avant(np.maximum(0, s.z))
    def arriere(s, g): g = s.l2.arriere(g) * (s.z > 0); out = s.l1.arriere(g); s.dp = s.l1.dp + s.l2.dp; return out
class Bloc:                                       # pré-LN : x + Attn(LN(x)) ; x + MLP(LN(x))
    def __init__(s, d, h): s.ln1, s.att, s.ln2, s.mlp = LayerNorm(d), Attention(d, h), LayerNorm(d), MLP(d); s.p = s.ln1.p + s.att.p + s.ln2.p + s.mlp.p
    def avant(s, x): x = x + s.att.avant(s.ln1.avant(x)); return x + s.mlp.avant(s.ln2.avant(x))
    def arriere(s, g): g = g + s.ln2.arriere(s.mlp.arriere(g)); g = g + s.ln1.arriere(s.att.arriere(g)); s.dp = s.ln1.dp + s.att.dp + s.ln2.dp + s.mlp.dp; return g
class GPT:
    def __init__(s, V, d, L, h, nmax):
        s.E = rng.normal(0, 0.1, (V, d)); s.P = rng.normal(0, 0.1, (nmax, d)); s.blocs = [Bloc(d, h) for _ in range(L)]; s.lnf = LayerNorm(d)
        s.p = [s.E, s.P] + sum((b.p for b in s.blocs), []) + s.lnf.p
    def avant(s, idx):
        s.idx = idx; x = s.E[idx] + s.P[:len(idx)]
        for b in s.blocs: x = b.avant(x)
        s.hf = s.lnf.avant(x); return s.hf @ s.E.T                       # poids de sortie liés à l'embedding
    def perte_et_grad(s, idx, cible):
        logits = s.avant(idx); p = softmax(logits); n = len(idx)
        L = -np.log(p[np.arange(n), cible] + 1e-12).mean()
        g = p.copy(); g[np.arange(n), cible] -= 1; g /= n                 # ∂ℓ/∂logits = p − y
        dE_out = g.T @ s.hf; g = s.lnf.arriere(g @ s.E)
        dp_blocs = []
        for b in reversed(s.blocs): g = b.arriere(g); dp_blocs = b.dp + dp_blocs
        dE = dE_out.copy(); np.add.at(dE, idx, g); dP = np.zeros_like(s.P); dP[:n] = g
        return L, [dE, dP] + dp_blocs + s.lnf.dp
# Langage jouet : "a b c a b c ..." avec des motifs à copier : le modèle doit apprendre (x_t | x_{t-3})
V, nmax = 6, 24
def phrase(): base = rng.integers(0, V, 3); return np.tile(base, 8)[:nmax + 1]
m = GPT(V, d=32, L=2, h=4, nmax=nmax); lr = 0.05; mom = [np.zeros_like(p) for p in m.p]
for it in range(300):
    s = phrase(); L, grads = m.perte_et_grad(s[:-1], s[1:])
    for p, g, v in zip(m.p, grads, mom): v *= 0.9; v += g; p -= lr * v
    if it % 60 == 0 or it == 299: print(f"itération {it:3d} : perte {L:.3f} (uniforme = {np.log(V):.3f})")
s = phrase(); pred = m.avant(s[:-1]).argmax(-1)
print("cible  :", s[1:][6:18]); print("prédit :", pred[6:18], "| exactitude après 6 tokens :", np.mean(pred[6:] == s[1:][6:]).round(2))

Un modèle de 2 blocs apprend le motif périodique en quelques centaines de pas : c’est une tête d’induction minimale (L15). Chaque ligne de ce code correspond à une équation de la fiche ; rien n’est caché.

02 / Analyser

Vue informatique : où va le calcul, où va la mémoire

import numpy as np
def profil(d, L, h, V, n, h_kv=None, dtype_octets=2):
    h_kv = h_kv or h; dk = d // h
    params = 12 * L * d * d + V * d
    flops_token = 2 * params + 2 * L * n * d                       # attention : n·d par couche (K et V complets)
    cache = 2 * L * n * h_kv * dk * dtype_octets
    attn_matrices = L * h * n * n * dtype_octets                    # si matérialisées (sans FlashAttention), par séquence
    return params, flops_token, cache, attn_matrices
modeles = {"GPT-2 small": (768, 12, 12, 50257, 1024, None), "LLaMA-2 7B": (4096, 32, 32, 32000, 4096, None), "LLaMA-2 70B (GQA)": (8192, 80, 64, 32000, 4096, 8), "Hypothétique 8k ctx, 175B": (12288, 96, 96, 50257, 8192, None)}
print(f"{'modèle':28s} {'params':>8s} {'GFLOP/token':>12s} {'cache KV/séq':>14s} {'attn n²/séq':>12s}")
for nom, (d, L, h, V, n, hkv) in modeles.items():
    p, f, c, a = profil(d, L, h, V, n, hkv)
    print(f"{nom:28s} {p/1e9:7.2f}G {f/1e9:12.1f} {c/1e9:12.2f} Go {a/1e9:10.1f} Go")
print("\nLecture : GQA (8 têtes KV au lieu de 64) divise le cache par 8 ; à 8k de contexte, les matrices d'attention")
print("matérialisées dépasseraient la mémoire d'un GPU (80 Go) → FlashAttention est indispensable, pas optionnel.")
# Temps de génération : le décodage est limité par la BANDE PASSANTE mémoire (lire tous les poids à chaque token), pas par le calcul
for nom, bw in (("A100 (2 To/s)", 2e12), ("H100 (3,35 To/s)", 3.35e12), ("PC, RTX 4090 (1 To/s)", 1e12)):
    p = profil(4096, 32, 32, 32000, 4096)[0]; print(f"{nom:24s} LLaMA-2 7B en fp16 : ≥ {p * 2 / bw * 1000:.0f} ms/token en lot de 1 → {bw / (p * 2):.0f} tokens/s max")

Retenir : à l’entraînement, le coût est ≈ 6ND et le calcul domine ; à l’inférence en petit lot, la bande passante mémoire domine (chaque token relit tous les poids) — d’où la quantification (4 bits : 4× moins d’octets), le traitement par lots, et la génération spéculative.

02 / Analyser

Vue mathématique : ce que l’attention peut et ne peut pas représenter

Ce qu’elle fait bien

Moyennes conditionnelles : la sortie est toujours dans l’enveloppe convexe des valeurs — une agrégation, pas une transformation ; la non-linéarité vient du softmax (sélection) et du MLP.
Recherche associative : une requête retrouve les clés proches ; avec des clés = positions, c’est un accès par adresse ; avec des clés = contenu, une mémoire associative (Hopfield moderne : Ramsauer 2020).
Composition en profondeur : deux couches composent des relations (tête d’induction : « ce qui suivait la dernière occurrence du token courant »).

Ses limites démontrées

Compter et parité : une couche d’attention à précision finie ne calcule pas la parité de n bits pour n arbitraire (Hahn 2020) ; en pratique, les modèles échouent sur des tâches de comptage long sans chaîne de raisonnement explicite.
Profondeur bornée ⇒ classe de circuits bornée : un transformer de profondeur L à précision log n est dans TC⁰ (Merrill & Sabharwal 2023) : il ne peut pas, en un passage, simuler des calculs séquentiels longs (d’où l’intérêt de « penser étape par étape », qui rallonge la séquence = plus de calcul).
Dilution : avec n tokens, chaque poids est ≈ 1/n en moyenne ; retrouver une aiguille exige un score très contrasté — les longs contextes dégradent le rappel (« lost in the middle », Liu 2023).

03 / Variantes

Encodeur, décodeur, encodeur-décodeur : quelle architecture pour quelle tâche

Famille	Attention	Pré-entraînement	Tâches	Exemples
Encodeur	Bidirectionnelle	Tokens masqués (MLM)	Classification, extraction, plongements, recherche (RAG !)	BERT, RoBERTa, DeBERTa, E5, BGE
Décodeur	Causale	Token suivant	Génération, dialogue, code, raisonnement	GPT, LLaMA, Mistral, Qwen, Claude
Encodeur-décodeur	Bidirectionnelle + causale + croisée	Débruitage de spans	Traduction, résumé, ASR (Whisper), OCR (TrOCR)	T5, BART, Whisper, mT5
Vision (ViT)	Bidirectionnelle sur patchs	Supervisé / auto-supervisé (MAE, DINO)	Classification, détection, segmentation	ViT, DINOv2, SAM
Multimodal	Croisée image→texte	Contrastif (CLIP) puis génératif	Description, VQA, OCR « libre », agents	CLIP, LLaVA, PaliGemma, GPT-4V
Alternatives linéaires	Récurrence à état (SSM)	Token suivant	Très longs contextes, embarqué	Mamba, RWKV, hybrides (Jamba)

Attention croisée (décodeur d’un encodeur-décodeur) : Q vient du décodeur, K et V de l’encodeur — le décodeur « lit » la source à chaque pas. C’est aussi le mécanisme des modèles de diffusion conditionnés par du texte.

Choisir : comprendre/classer/plonger → encodeur (petit, rapide, bidirectionnel) ; produire du texte → décodeur ; transformer une séquence en une autre de nature différente → encodeur-décodeur ; contexte de 10⁶ tokens sous contrainte mémoire → hybride SSM.

04 / Entraîner à l’échelle

Lois d’échelle, données, et le calcul que vous n’avez pas

import numpy as np
# Loi de Chinchilla (Hoffmann et al. 2022, ajustement paramétrique) : L(N, D) = E + A / N^alpha + B / D^beta
E, A, B, alpha, beta = 1.69, 406.4, 410.7, 0.34, 0.28
def perte(N, D): return E + A / N**alpha + B / D**beta
def optimum(C):                                       # à calcul C = 6 N D fixé, minimiser L sur N
    Ns = np.logspace(6, 13, 2000); Ds = C / (6 * Ns); Ls = perte(Ns, Ds); i = Ls.argmin(); return Ns[i], Ds[i], Ls[i]
print(f"{'calcul (FLOPs)':>16s} {'N optimal':>12s} {'D optimal':>12s} {'D/N':>6s} {'perte':>6s}")
for C in (1e18, 1e20, 1e22, 1e24):
    N, D, L = optimum(C); print(f"{C:16.0e} {N:12.2e} {D:12.2e} {D/N:6.0f} {L:6.3f}")
print("\nGPT-3 (175B, 300G tokens, ~3e23 FLOPs) vs Chinchilla (70B, 1,4T tokens, même calcul) :", f"{perte(175e9, 300e9):.3f} vs {perte(70e9, 1.4e12):.3f}")
print("LLaMA-3 8B entraîné sur 15T tokens (D/N ≈ 1900) : « sur-entraîné » volontairement — moins cher à SERVIR pour une perte donnée :", f"{perte(8e9, 15e12):.3f}")
print("Avec 1 GPU pendant 1 semaine (~1e19 FLOPs utiles) :", "N ≈ %.0f M, D ≈ %.1f G tokens" % (optimum(1e19)[0] / 1e6, optimum(1e19)[1] / 1e9))

Leçon d’ingénierie : le pré-entraînement à l’état de l’art coûte 10⁷ à 10⁹ €. Votre levier n’est pas là : il est dans l’affinage (LoRA, quelques heures de GPU), le RAG (L26), les données (L36) et l’évaluation (L32). Entraîner « from scratch » est le dernier recours (L37).

05 / Articles

Les articles à lire, avec ce qu’il faut en retenir

Article	Contribution	À retenir / limite
Vaswani et al., Attention Is All You Need, NeurIPS 2017 — arXiv:1706.03762	Architecture sans récurrence ; attention multi-têtes ; encodage sinusoïdal ; SOTA en traduction	Post-LN, warmup indispensable ; le tableau 1 (complexité par couche) explique tout
Devlin et al., BERT, 2018 — 1810.04805	Pré-entraînement bidirectionnel par tokens masqués ; affinage universel	Base des modèles de plongement et de recherche ; pas génératif
Radford et al., GPT-2 2019 ; Brown et al., GPT-3, 2020 — 2005.14165	Décodeur causal à l’échelle ; apprentissage en contexte (few-shot) émerge	La taille change la nature des capacités ; évaluation par prompts
Kaplan et al., Scaling Laws, 2020 — 2001.08361 ; Hoffmann et al., Chinchilla, 2022 — 2203.15556	Perte en loi de puissance de N, D, C ; optimum N ≈ D/20	Kaplan sous-estimait les données ; les lois dépendent du corpus et de la tokenisation
Xiong et al., On Layer Normalization in the Transformer, ICML 2020 — 2002.04745	Pré-LN : gradients bornés à l’initialisation, pas de warmup nécessaire	Explique le choix de tous les LLM modernes
Su et al., RoFormer (RoPE), 2021 — 2104.09864	Position relative par rotation de q, k	Extension de contexte par interpolation (Chen 2023, YaRN)
Dao et al., FlashAttention, NeurIPS 2022 — 2205.14135 ; v2 2023	Attention exacte par blocs, IO-aware ; mémoire O(n)	Le goulot est la mémoire, pas les FLOPs ; adopté partout
Shazeer, Fast Transformer Decoding (MQA), 2019 — 1911.02150 ; Ainslie et al., GQA, 2023 — 2305.13245	Partager K, V entre têtes : cache KV réduit	Qualité quasi intacte ; standard dans LLaMA-2/3, Mistral
Touvron et al., LLaMA, 2023 — 2302.13971	Modèles ouverts entraînés au-delà de Chinchilla ; RMSNorm, SwiGLU, RoPE	La recette « moderne » standard
Gu & Dao, Mamba, 2023 — 2312.00752	Modèle à état sélectif, linéaire en n	Compétitif jusqu’à ~3B ; hybrides attention + SSM en production
Dosovitskiy et al., ViT, ICLR 2021 — 2010.11929	Images en patchs = tokens ; transformer pur en vision	Exige beaucoup de données ou un pré-entraînement auto-supervisé
Olsson et al., In-context Learning and Induction Heads, 2022 — 2209.11895	Mécanisme concret de l’apprentissage en contexte	Interprétabilité mécaniste : lire les circuits, pas seulement les scores

Méthode de lecture : trois passes (L24). Pour chacun, remplir : contribution en 3 phrases, protocole, résultat clé (chiffre), limite avouée, limite non avouée.

TP guidé

TP — nanoGPT sur PC : entraîner, mesurer, modifier (6 h)

Installer. pip install torch numpy tiktoken ; cloner karpathy/nanoGPT ; jeu de données Shakespeare au niveau caractère (data/shakespeare_char/prepare.py).
Entraîner la baseline. python train.py config/train_shakespeare_char.py (CPU : 30 min pour des résultats lisibles ; GPU : 5 min). Noter la perte de validation finale et le temps ; échantillonner (sample.py).
Vérifier la théorie. Compter les paramètres (formule 12Ld² + Vd) et comparer au model.get_num_params(). Mesurer le temps par itération pour n = 64, 128, 256 : la partie attention doit croître en n².
Ablations. (a) Retirer l’encodage de position : que se passe-t-il ? (b) Post-LN au lieu de pré-LN : la perte diverge-t-elle sans warmup ? (c) Une seule tête vs 6 ; (d) sans connexions résiduelles à 6 couches. Un tableau : configuration, perte val, temps.
Cache KV. Implémenter la génération avec cache dans model.generate (garder K, V par couche) ; vérifier l’identité des sorties avec la génération naïve ; mesurer l’accélération pour 500 tokens.
FlashAttention. Activer torch.nn.functional.scaled_dot_product_attention (déjà dans nanoGPT si PyTorch ≥ 2) ; comparer mémoire (torch.cuda.max_memory_allocated) et vitesse avec l’attention manuelle, pour n = 1024.
Livrable. Dépôt avec le tableau d’ablations (5 graines pour la baseline et la meilleure variante, moyenne ± écart-type), les mesures de coût, la génération avec cache, et une page « ce que j’ai vérifié des articles ».

Exercices

Exercices auto-corrigés

Exercice 1 — RoPE

Implémentez rope(x, pos, theta_base=10000) qui applique la rotation par paires de dimensions (2i, 2i+1) d’angle pos·θ_i, θ_i = base^−2i/d, à un vecteur x de dimension d paire. Vérifiez que le produit scalaire ne dépend que de la différence de positions.

Correction

def rope(x, pos, theta_base=10000):
    d = len(x); i = np.arange(d // 2); theta = theta_base ** (-2 * i / d); a = pos * theta
    x1, x2 = x[0::2], x[1::2]
    y = np.empty_like(x); y[0::2] = x1 * np.cos(a) - x2 * np.sin(a); y[1::2] = x1 * np.sin(a) + x2 * np.cos(a)
    return y

Exercice 2 — Softmax par blocs (FlashAttention)

Implémentez attention_par_blocs(q, K, V, taille_bloc) pour une seule requête q : parcourez K, V par blocs en maintenant (m, l, o) selon le Théorème 4, sans jamais former le vecteur complet des scores. Comparez à l’attention directe.

Correction

def attention_par_blocs(q, K, V, taille_bloc):
    dk = len(q); m, l, o = -np.inf, 0.0, np.zeros(V.shape[1])
    for deb in range(0, len(K), taille_bloc):
        s = K[deb:deb + taille_bloc] @ q / np.sqrt(dk)
        m2 = max(m, s.max()); f = np.exp(m - m2) if m > -np.inf else 0.0; e = np.exp(s - m2)
        l = f * l + e.sum(); o = f * o + e @ V[deb:deb + taille_bloc]; m = m2
    return o / l

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — GQA

Implémentez attention_gqa(X, Wq, Wk, Wv, h, g) : h têtes de requêtes, g groupes de K/V (h divisible par g) ; les têtes q_0..h/g−1 utilisent le groupe 0, etc. Vérifiez que g = h redonne l’attention multi-têtes classique, et que g = 1 est la MQA. Retournez aussi le nombre de valeurs du cache KV.

import numpy as np
def attention_gqa(X, Wq, Wk, Wv, h, g, causal=True):
    """Wq : (d, h*dk) ; Wk, Wv : (d, g*dk). Retourne (sortie (n, h*dk), taille_cache_KV)."""
    ...   # à vous

rng = np.random.default_rng(2); n, d, h, dk = 6, 32, 8, 4; X = rng.normal(0, 1, (n, d))
Wq = rng.normal(0, 0.2, (d, h * dk)); Wk8, Wv8 = rng.normal(0, 0.2, (d, 8 * dk)), rng.normal(0, 0.2, (d, 8 * dk))
Y8, c8 = attention_gqa(X, Wq, Wk8, Wv8, h, 8); Y1, c1 = attention_gqa(X, Wq, Wk8[:, :dk], Wv8[:, :dk], h, 1); Y2, c2 = attention_gqa(X, Wq, Wk8[:, :2 * dk], Wv8[:, :2 * dk], h, 2)
assert Y8.shape == (n, h * dk) and c8 == 2 * n * 8 * dk and c1 == 2 * n * dk and c2 == 2 * n * 2 * dk
# référence multi-têtes classique pour g = h
def mha(X, Wq, Wk, Wv, h):
    Q, K, V = X @ Wq, X @ Wk, X @ Wv; outs = []
    for i in range(h):
        q, k, v = Q[:, i*dk:(i+1)*dk], K[:, i*dk:(i+1)*dk], V[:, i*dk:(i+1)*dk]; S = q @ k.T / np.sqrt(dk) + np.triu(np.full((n, n), -1e9), 1)
        A = np.exp(S - S.max(1, keepdims=True)); A /= A.sum(1, keepdims=True); outs.append(A @ v)
    return np.concatenate(outs, 1)
assert np.allclose(Y8, mha(X, Wq, Wk8, Wv8, h))
# MQA : toutes les têtes partagent K, V → chaque tête voit les mêmes valeurs, seules les requêtes diffèrent
assert not np.allclose(Y1[:, :dk], Y1[:, dk:2*dk])
print("✔ exercice 3 réussi")

Correction

def attention_gqa(X, Wq, Wk, Wv, h, g, causal=True):
    n = len(X); dk = Wq.shape[1] // h; Q, K, V = X @ Wq, X @ Wk, X @ Wv; outs = []
    for i in range(h):
        grp = i // (h // g); q = Q[:, i*dk:(i+1)*dk]; k = K[:, grp*dk:(grp+1)*dk]; v = V[:, grp*dk:(grp+1)*dk]
        S = q @ k.T / np.sqrt(dk)
        if causal: S = S + np.triu(np.full((n, n), -1e9), 1)
        A = np.exp(S - S.max(1, keepdims=True)); A /= A.sum(1, keepdims=True); outs.append(A @ v)
    return np.concatenate(outs, 1), 2 * n * g * dk

Exercice 4 — Dimensionner

Complétez dimensionner(C) qui, pour un budget de calcul C (FLOPs), renvoie (N, D) selon Chinchilla (D = 20N, C = 6ND), puis (d, L) pour un modèle « carré » avec d = 128·L (h = d/128, d_ff = 4d, V = 32 000) tel que 12Ld² + Vd ≈ N.

Correction

def dimensionner(C, V=32000):
    N = np.sqrt(C / 120); D = 20 * N                      # C = 6·N·20N = 120 N²
    Ls = np.linspace(1, 200, 100000); ds = 128 * Ls; params = 12 * Ls * ds**2 + V * ds
    L = Ls[np.abs(params - N).argmin()]; return N, D, 128 * L, L

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Montrer que la sortie d’une tête d’attention est dans l’enveloppe convexe des lignes de V, et en déduire qu’une couche d’attention seule (sans MLP) ne peut pas produire un vecteur de norme supérieure au maximum des normes des valeurs.

Correction. La ligne t de la sortie est Σ_j a_tjv_j avec a_tj ≥ 0 et Σ_j a_tj = 1 (softmax) : combinaison convexe. Par l’inégalité triangulaire, ‖Σ a_tjv_j‖ ≤ Σ a_tj‖v_j‖ ≤ max_j‖v_j‖. L’attention agrège ; la projection W_O et le MLP transforment. C’est pourquoi un bloc contient les deux, et pourquoi le MLP porte ≈ 2/3 des paramètres.

Exercice 2. On génère 2 000 tokens avec LLaMA-2 7B en fp16 sur un GPU de 24 Go. Le cache KV tient-il ? Et pour 32 000 tokens ? Que change GQA à 8 têtes KV ?

Correction. Poids : 7·10⁹ × 2 octets = 13,5 Go. Cache par token : 2 × L × h × d_k × 2 octets = 2 × 32 × 32 × 128 × 2 = 524 288 octets = 0,5 Mo. 2 000 tokens : 1 Go — total 14,5 Go, ça tient. 32 000 tokens : 16,8 Go + 13,5 Go = 30 Go > 24 Go : ne tient pas. Avec GQA (8 têtes KV) : cache divisé par 4 → 4,2 Go, total 17,7 Go, ça tient. Alternative : quantifier les poids en 4 bits (3,5 Go) et le cache en 8 bits.

Exercice 3. Pourquoi le pré-LN se passe-t-il de warmup alors que le post-LN en a besoin ? Donner l’argument sur la norme du gradient à l’initialisation.

Correction. En post-LN, la sortie de chaque bloc est renormalisée : le gradient qui traverse L blocs est multiplié par L jacobiens de LayerNorm et de sous-couches, et Xiong et al. montrent que sa norme aux dernières couches croît comme O(d·√(ln d)) indépendamment de L tandis que celle des premières décroît — un grand pas initial fait diverger ; le warmup (pas croissant de 0) laisse les poids s’adapter. En pré-LN, le flux résiduel x n’est jamais renormalisé : ∂x_L/∂x_ℓ = I + (termes de sous-couches), de norme O(1) à l’initialisation, et la norme du gradient est bornée par O(√(ln d)/√L) : le pas peut être grand dès le départ. Contrepartie : le flux résiduel grossit avec la profondeur (d’où la LN finale).

Vérification

Pourquoi la génération token par token d’un LLM en lot de 1 est-elle lente sur GPU alors que le calcul par token est faible ?

Deux questions supplémentaires

1. Pourquoi diviser par √d_k ? Pour garder la variance des scores à 1 et éviter la saturation du softmax (gradient nul).

2. Que gagne FlashAttention ? La même attention exacte sans matérialiser la matrice n×n : mémoire O(n), et 2–4× plus rapide grâce à la SRAM.

Référence

Les mots à retenir

Mot	Définition
Tête d’attention	softmax(QKᵀ/√d_k)V : moyenne des valeurs pondérée par la similarité requête-clé.
Pré-LN	Normalisation à l’entrée des sous-couches ; flux résiduel non normalisé ; gradients stables.
Cache KV	Mémorisation des K, V passés en génération ; coût par token linéaire.
MQA / GQA	K, V partagés entre têtes (ou groupes) : cache réduit.
RoPE	Rotation de q, k selon la position ; score dépendant de la position relative.
FlashAttention	Softmax par blocs, sans matrice n×n, adapté à la hiérarchie mémoire.
Loi d’échelle	Perte en loi de puissance de N, D, C ; Chinchilla D ≈ 20N.
Encodeur / décodeur	Bidirectionnel (comprendre) / causal (générer) / les deux (transformer une séquence).

Suite

Vous avez démonté le moteur. Maintenant, la voiture : comment on l’utilise en production.

Un transformer seul ne sait rien de vos documents, et se trompe avec assurance. Le chapitre suivant construit un RAG — recherche + génération — et montre comment le mesurer.

← L24 Sommaire L26 : RAG →