Module L15 · Partie H · Intelligence artificielle

Comment fonctionne un grand modèle de langage.

ChatGPT, Claude, Gemini : des transformeurs, entraînés à prédire le mot suivant. Ce module part du modèle de langue le plus simple (compter les paires de lettres), passe par les plongements et les réseaux récurrents, puis construit le mécanisme d’attention et un mini-transformeur en NumPy. À la fin, vous aurez entraîné dans la page un modèle qui génère des noms de robots plausibles — et vous saurez ce qui se passe derrière chaque réponse d’un assistant IA.

Durée : 4 séances · Prérequis : L14. Objectifs : modèle de langue et perplexité, tokenisation, plongements (embeddings), RNN et leurs limites, attention (Q, K, V), attention multi-têtes et masquage causal, blocs transformeurs, pré-entraînement / ajustement / RLHF (vue d’ensemble), lois d’échelle, limites et questions ouvertes.

Ce que vous saurez faire à la fin

Expliquer et coder le calcul d’attention et sa complexité en O(n²).
Entraîner un modèle de langue au niveau caractère et en générer des textes.
Lire l’architecture d’un transformeur (GPT) et situer chaque composant.
Discuter les limites (hallucinations, contexte, coût) avec des arguments techniques.

Références : « Attention Is All You Need » (Vaswani et al., 2017), « The Illustrated Transformer » (Alammar), « Let’s build GPT » et « makemore » (Karpathy), cours CS224n (Stanford), Dive into Deep Learning chapitres 9-11.

Fiche de cours · Définitions

Deep learning et transformers : définitions

Définition (token, plongement, vocabulaire). Un texte est découpé en tokens (sous-mots, BPE) d’un vocabulaire de taille V. Chaque token est représenté par un vecteur appris de dimension d (plongement, embedding) : matrice E de taille V×d. Une séquence de n tokens devient une matrice X de taille n×d.

Définition (attention). À partir de X, on calcule requêtes Q = XW_Q, clés K = XW_K, valeurs V = XW_V (dimensions d_k, d_k, d_v). Attention(Q, K, V) = softmax(QKᵀ/√d_k)·V : chaque position produit une moyenne pondérée des valeurs, les poids mesurant la similarité requête-clé. Multi-têtes : h attentions en parallèle sur des projections différentes, concaténées.

Définition (bloc transformer). x ← x + MultiHead(LN(x)) ; x ← x + MLP(LN(x)), avec LN la normalisation de couche et deux connexions résiduelles. Un modèle empile L blocs. Encodeur : attention bidirectionnelle (BERT). Décodeur : attention causale (masque triangulaire : une position ne voit que les précédentes) pour la génération (GPT).

Définition (encodage de position). L’attention est invariante par permutation des positions : on ajoute à chaque token un vecteur dépendant de sa position (sinusoïdal, appris, ou rotatif RoPE).

Définition (modèle de langue, pré-entraînement, affinage). Un modèle de langue estime P(token_t | tokens_<t). Pré-entraînement auto-supervisé sur un grand corpus (prédire le token suivant), puis affinage (fine-tuning) sur une tâche, ou instruction/RLHF pour suivre des consignes. La perplexité exp(perte moyenne) mesure la qualité du modèle de langue.

Définition (génération). Décodage glouton (argmax), échantillonnage avec température T (softmax(z/T)), top-k, nucleus (top-p), recherche en faisceau (beam search, largeur B).

Fiche de cours · Formules

Formules à connaître

Attention(Q, K, V) = softmax(QKᵀ/√d_k) V — coût O(n²·d) en temps, O(n²) en mémoire pour les poids d’attention

LayerNorm(x) = γ ⊙ (x − μ)/√(σ² + ε) + β, μ et σ² calculées sur les d composantes du vecteur

Encodage sinusoïdal : PE(pos, 2i) = sin(pos/10000^2i/d), PE(pos, 2i+1) = cos(pos/10000^2i/d)

Perte du modèle de langue : L = −(1/n)Σ_t log P(x_t | x_<t) ; perplexité = e^L

Paramètres d’un bloc ≈ 12d² (4d² attention + 8d² MLP à facteur 4) ; modèle ≈ 12Ld² + Vd

FLOPs d’entraînement ≈ 6 × N_params × N_tokens ; inférence ≈ 2 × N_params par token généré

Lois d’échelle (Chinchilla) : à budget fixe, N_tokens ≈ 20 × N_params

Architecture	Données	Inductive bias	Coût par couche
MLP	Vecteurs	Aucun	O(d²)
CNN	Images, signaux	Localité, translation	O(n·k²·C²)
RNN / LSTM	Séquences	Ordre, récurrence	O(n·d²), séquentiel
Transformer	Séquences, images (patchs), graphes	Aucun sur la position (ajouté), tout-à-tout	O(n²d + nd²), parallèle

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

Démonstrations à savoir refaire (1/2)

Théorème 1 (pourquoi diviser par √d_k). Si les composantes de q et k sont i.i.d. centrées de variance 1, alors qᵀk a une variance d_k ; qᵀk/√d_k a une variance 1.

qᵀk = Σ_i=1^d_k q_ik_i. Chaque terme est centré (E[q_ik_i] = E[q_i]E[k_i] = 0) de variance E[q_i²]E[k_i²] = 1, et les termes sont indépendants : Var = d_k. Diviser par √d_k ramène la variance à 1. Sans cela, pour d_k = 64, les logits ont un écart-type 8 : le softmax devient quasi one-hot (saturation), et son gradient p_k(1 − p_k) tend vers 0 — l’attention n’apprend plus.

Théorème 2 (l’attention est invariante par permutation). Si P est une matrice de permutation des positions, Attention(PQ, PK, PV) = P·Attention(Q, K, V).

(PQ)(PK)ᵀ = PQKᵀPᵀ ; le softmax ligne par ligne commute avec la permutation des lignes et des colonnes : softmax(PMPᵀ) = P·softmax(M)·Pᵀ. Puis P·softmax(M)·Pᵀ·PV = P·softmax(M)·V car PᵀP = I. La sortie à la position permutée est la sortie originale : le modèle ne « sait » pas où sont les tokens. D’où la nécessité d’un encodage de position, et l’aptitude naturelle des transformers aux ensembles (nuages de points, graphes).

Théorème 3 (l’encodage sinusoïdal code les décalages linéairement). Pour tout décalage k, il existe une matrice M_k (indépendante de pos) telle que PE(pos + k) = M_k·PE(pos).

Pour chaque fréquence ω_i = 10000^−2i/d, la paire (sin(ω_ipos), cos(ω_ipos)) devient (sin(ω_i(pos + k)), cos(ω_i(pos + k))) = R(ω_ik)·(sin, cos) par les formules d’addition — une rotation d’angle ω_ik. M_k est diagonale par blocs de rotations 2×2. Une projection linéaire (W_Q, W_K) peut donc exprimer « le token à distance k », quelle que soit la position absolue. RoPE pousse l’idée jusqu’au bout en appliquant ces rotations directement à q et k, de sorte que qᵀk ne dépende que de la distance relative.

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

Démonstrations à savoir refaire (2/2)

Théorème 4 (masque causal et factorisation). Avec un masque triangulaire (−∞ sur les positions futures avant le softmax), la sortie à la position t ne dépend que de x_≤t ; le modèle définit alors une loi jointe valide P(x₁…x_n) = Π_t P(x_t | x_<t), et l’entraînement sur toutes les positions d’une séquence se fait en un seul passage avant.

Le softmax d’une ligne ayant −∞ aux colonnes j > t donne un poids e^−∞ = 0 à ces colonnes : la sortie t est une combinaison des valeurs V_≤t, elles-mêmes fonctions de x_≤t ; par récurrence sur les couches, idem à toutes les profondeurs. La règle de la chaîne des probabilités P(x₁…x_n) = Π P(x_t | x_<t) est une identité toujours vraie ; le modèle fournit chaque facteur. Comme les n prédictions sont calculées simultanément (une matrice n×n d’attention), une séquence de n tokens fournit n exemples d’entraînement pour le prix d’un passage — c’est ce qui rend le pré-entraînement à grande échelle possible, contrairement aux RNN séquentiels.

Théorème 5 (la température contrôle l’entropie de l’échantillonnage). Pour p_T = softmax(z/T) : T → 0 donne l’argmax (entropie 0), T = 1 la loi du modèle, T → ∞ la loi uniforme (entropie log V) ; l’entropie est croissante en T.

p_T,k = e^z_k/T/Σe^z_j/T. Quand T → 0, le terme de plus grand z_k domine exponentiellement : p → one-hot. Quand T → ∞, tous les exposants tendent vers 0 : p → 1/V. Monotonie : dH/dT = Var_{p_T}(z)/T³ ≥ 0 (calcul direct à partir de H = −Σp log p et de la dérivée de la log-partition, dont la dérivée seconde en 1/T est la variance de z). En pratique : T ≈ 0,7 pour du code (précision), T ≈ 1 pour de la créativité ; top-p coupe la queue de faibles probabilités qui produit les tokens absurdes.

Proposition 6 (coût quadratique et fenêtre de contexte). Doubler la longueur de contexte n quadruple la mémoire des matrices d’attention (n² par tête et par couche) et le temps de la partie attention.

QKᵀ est n×n ; L couches × h têtes → L·h·n² valeurs. Pour n = 8 192, h = 32, L = 32 : 6,9·10¹⁰ valeurs par séquence (en float16, 137 Go) — d’où FlashAttention (calcul par blocs sans matérialiser la matrice), l’attention locale/sparse, et les modèles à état (Mamba) linéaires en n.

Fiche de cours · Méthodes

Méthodes et pièges

Méthode — implémenter un transformer minimal (ordre de vérification). (1) Embedding + position, vérifier les formes (n×d). (2) Une tête d’attention sans masque : sortie = moyenne des V si Q = 0 (test). (3) Masque causal : vérifier que modifier x_t+1 ne change pas la sortie t. (4) Multi-têtes, résiduel, LayerNorm. (5) Sur-apprendre une séquence de 100 tokens : perte → 0. (6) Comparer la perplexité à un bigramme (L15 module) : le transformer doit faire nettement mieux.

Méthode — utiliser un modèle pré-entraîné. Ne jamais entraîner from scratch si un modèle pré-entraîné existe : affiner (fine-tuning complet, ou LoRA : matrices de rang faible ajoutées aux poids, 100× moins de paramètres à apprendre), ou simplement extraire des plongements et entraîner un petit classifieur dessus. Toujours comparer à « zéro-shot » avec un bon prompt.

Méthode — évaluer un modèle génératif. Perplexité sur un corpus tenu à l’écart ; métriques de tâche (exactitude sur un jeu de questions, BLEU/ROUGE pour traduction/résumé, avec leurs limites) ; évaluation humaine ou par modèle juge sur un échantillon ; tests de contamination (les données de test sont-elles dans le corpus d’entraînement ?).

Pièges : oublier le masque causal en génération (le modèle « triche » à l’entraînement puis échoue) ; tokenisation différente entre entraînement et inférence ; fenêtre de contexte dépassée silencieusement ; comparer des modèles à des nombres de tokens vus différents ; confondre « le modèle produit une phrase plausible » et « vraie ».

Fiche de cours · Exercices corrigés

Exercices corrigés

Exercice 1. Calculer à la main une attention pour 3 tokens en dimension 2 : Q = K = [[1, 0], [0, 1], [1, 1]], V = [[1, 0], [0, 1], [1, 1]], d_k = 2. Donner la sortie de la position 3 sans masque, puis avec masque causal pour la position 2.

Correction. Position 3 : q₃ = (1, 1) ; scores q₃ᵀk_j/√2 = (1, 1, 2)/1,414 = (0,707 ; 0,707 ; 1,414). Softmax : e^0,707 = 2,03, e^1,414 = 4,11 ; somme 8,17 ; poids (0,248 ; 0,248 ; 0,503). Sortie = 0,248·(1, 0) + 0,248·(0, 1) + 0,503·(1, 1) = (0,751 ; 0,751). Position 2 avec masque (voit 1 et 2) : q₂ = (0, 1), scores (0, 1)/1,414 = (0 ; 0,707), le troisième est −∞. Softmax : (1, 2,03)/3,03 = (0,330 ; 0,670). Sortie = 0,330·(1, 0) + 0,670·(0, 1) = (0,330 ; 0,670). La position 2 s’attend surtout à elle-même.

Exercice 2. Un modèle a d = 1 024, L = 24, h = 16, V = 50 000. Estimer le nombre de paramètres, le coût d’entraînement sur 100 milliards de tokens en FLOPs, et le temps sur un GPU à 10¹⁴ FLOP/s utile.

Correction. Blocs : 12·L·d² = 12·24·1,05·10⁶ ≈ 3,0·10⁸. Embeddings : V·d = 5,1·10⁷ (souvent partagés avec la sortie). Total ≈ 3,5·10⁸ paramètres (« 350 M »). FLOPs ≈ 6·N·D = 6·3,5·10⁸·10¹¹ = 2,1·10²⁰. Temps = 2,1·10²⁰/10¹⁴ = 2,1·10⁶ s ≈ 24 jours sur un GPU ; 8 GPU → 3 jours (si le parallélisme est efficace). Chinchilla suggère D ≈ 20N = 7·10⁹ tokens pour ce modèle : 100 G tokens est « sur-entraîné », ce qui est un choix courant pour l’inférence (petit modèle, beaucoup de données).

Exercice 3. Montrer qu’une tête d’attention peut implémenter exactement « copier le token précédent » avec un encodage de position approprié, et expliquer le lien avec les têtes d’induction.

Correction. Supposons que le plongement de la position t contienne un vecteur p_t avec p_tᵀp_s = 1 si s = t − 1 et 0 sinon (approximativement réalisable avec des sinusoïdes de fréquences variées, ou exactement avec des positions one-hot décalées). Prendre W_Q et W_K qui extraient ces vecteurs, avec un grand gain β : score(t, s) = β·p_tᵀp_s vaut β en s = t − 1, 0 ailleurs ; le softmax concentre le poids sur t − 1 ; W_V = identité recopie le token précédent. Une tête d’induction enchaîne deux têtes : la première écrit « le token qui me précède » dans chaque position, la seconde cherche la position passée dont le token précédent est égal au token courant et copie ce qui la suivait — c’est le mécanisme « [A][B] … [A] → [B] » qui explique une part de l’apprentissage en contexte des LLM (Olsson et al., 2022).

01 / Modèles de langue

Le modèle le plus simple : compter les bigrammes

import numpy as np
rng = np.random.default_rng(0)

NOMS = """atlas nova orion vega titan iris pixel vortex zephyr helix nexus argo lumen kilo bolt rover
astra cyber delta echo fenix gizmo hydra ion juno kepler lyra mira neon opal pulsar quark rex sirius
tango ultra volt wren xeno yara zeta alpha bravo comet dyna ember flux gamma hertz ionos jet kappa
lima magno nano omega proto quanta rho sol tera umbra vita watt xylo yotta zion aero byte coda
data eon fibre gyro halo inti jade krypt lazer meta nitro octo photon quill radar sonar turbo unit
vector wave xan yoke zero""".split()
print(len(NOMS), "noms d'entraînement")

chars = sorted(set("".join(NOMS))) + ["."]         # « . » = début et fin de mot
idx = {c: i for i, c in enumerate(chars)}; V = len(chars)
N = np.full((V, V), 0.1)                             # comptes des paires (lissage +0,1 : aucune paire à probabilité nulle)
for nom in NOMS:
    s = "." + nom + "."
    for a, b in zip(s, s[1:]): N[idx[a], idx[b]] += 1
P = N / N.sum(1, keepdims=True)                      # P[a, b] = probabilité de b après a

def generer_bigramme(n=8):
    for _ in range(n):
        c, mot = idx["."], ""
        while True:
            c = rng.choice(V, p=P[c])
            if chars[c] == ".": break
            mot += chars[c]
        print(mot, end="  ")
    print()
generer_bigramme()

# Qualité : log-vraisemblance moyenne (plus haute = mieux) ; perplexité = exp(−moyenne)
ll = np.mean([np.log(P[idx[a], idx[b]]) for nom in NOMS for a, b in zip("." + nom + ".", nom + ".")])
print(f"log-vraisemblance moyenne {ll:.3f}, perplexité {np.exp(-ll):.1f} (uniforme : {V})")

Ce qu’est un modèle de langue

Une distribution de probabilité sur le prochain symbole sachant les précédents : P(x_t | x_1 … x_{t−1}). Générer = tirer au sort selon cette distribution, symbole après symbole. Évaluer = mesurer la probabilité que le modèle attribue à des textes réels (perplexité : « entre combien de choix le modèle hésite »). Le bigramme ne regarde que la lettre précédente ; GPT regarde des milliers de mots. Mais l’objectif, la génération et l’évaluation sont identiques. Le fameux « prédire le mot suivant » est exactement ceci, à grande échelle.

01 / Modèles de langue

Plongements : des symboles aux vecteurs

import numpy as np
# Un-chaud (one-hot) : V dimensions, aucune similarité entre symboles. Plongement : d dimensions apprises.
d = 4
E = rng.normal(0, 1, (V, d))                         # table de plongement : ligne i = vecteur du symbole i
print("vecteur de 'a' :", E[idx["a"]].round(2))

# Le bigramme comme réseau : logits = E[x] @ W ; on apprend E et W par gradient (cf. L14)
X = np.array([idx[a] for nom in NOMS for a in "." + nom]); Y = np.array([idx[b] for nom in NOMS for b in nom + "."])
W = rng.normal(0, 0.5, (d, V))
for it in range(300):
    Z = E[X] @ W; Z -= Z.max(1, keepdims=True); p = np.exp(Z); p /= p.sum(1, keepdims=True)
    perte = -np.log(p[np.arange(len(Y)), Y]).mean()
    dZ = p.copy(); dZ[np.arange(len(Y)), Y] -= 1; dZ /= len(Y)
    dW = E[X].T @ dZ; dE = np.zeros_like(E); np.add.at(dE, X, dZ @ W.T)      # gradient du plongement
    W -= 5 * dW; E -= 5 * dE
print(f"perte bigramme appris : {perte:.3f} (comptage : {-ll:.3f})")

# Les plongements appris rapprochent les lettres au comportement similaire
def voisins(c, k=3):
    v = E[idx[c]]; sims = E @ v / (np.linalg.norm(E, axis=1) * np.linalg.norm(v) + 1e-9)
    return [chars[i] for i in np.argsort(-sims)[1:k + 1]]
for c in "aeior": print(c, "→", voisins(c))

Dans un LLM, la table E a ~100 000 lignes (les tokens : morceaux de mots) et 4 000 à 16 000 colonnes. Les fameuses analogies « roi − homme + femme ≈ reine » (word2vec, 2013) viennent de ce que les plongements appris par prédiction du contexte capturent des régularités sémantiques — sans qu’on les ait programmées.

02 / Séquences

Réseau récurrent : un état qui résume le passé, et pourquoi il oublie

import numpy as np
# RNN : h_t = tanh(W_h h_{t−1} + W_x x_t + b) ; sortie = W_y h_t. L'état h porte la mémoire.
H = 16
Wx, Wh, Wy = rng.normal(0, 0.3, (V, H)), rng.normal(0, 0.3, (H, H)), rng.normal(0, 0.3, (H, V))
bh, by = np.zeros(H), np.zeros(V)

def passe_avant(seq):
    hs, ps, h = [np.zeros(H)], [], np.zeros(H)
    for t in range(len(seq) - 1):
        h = np.tanh(Wx[seq[t]] + Wh @ h + bh); hs.append(h)
        z = Wy.T @ h + by; z -= z.max(); p = np.exp(z); p /= p.sum(); ps.append(p)
    return hs, ps

# Rétropropagation à travers le temps (BPTT) : le gradient traverse chaque pas, multiplié par Wh et tanh'
def gradient_seq(seq):
    hs, ps = passe_avant(seq); n = len(ps)
    dWx, dWh, dWy, dbh, dby = [np.zeros_like(m) for m in (Wx, Wh, Wy, bh, by)]
    dh_suivant = np.zeros(H); perte = 0
    for t in reversed(range(n)):
        p = ps[t].copy(); perte -= np.log(p[seq[t + 1]]); p[seq[t + 1]] -= 1
        dWy += np.outer(hs[t + 1], p); dby += p
        dh = Wy @ p + dh_suivant
        dz = dh * (1 - hs[t + 1]**2)                       # tanh'
        dWx[seq[t]] += dz; dWh += np.outer(dz, hs[t]); dbh += dz
        dh_suivant = Wh.T @ dz
    return perte / n, (dWx, dWh, dWy, dbh, dby)

seqs = [[idx[c] for c in "." + nom + "."] for nom in NOMS]
for epoch in range(60):
    total = 0
    for s in rng.permutation(len(seqs)):
        perte, grads = gradient_seq(seqs[s]); total += perte
        for M, g in zip((Wx, Wh, Wy, bh, by), grads): M -= 0.05 * np.clip(g, -1, 1)     # écrêtage du gradient
    if epoch % 20 == 19: print(f"epoch {epoch + 1}: perte {total / len(seqs):.3f}")

def generer_rnn(n=8):
    for _ in range(n):
        h, c, mot = np.zeros(H), idx["."], ""
        for _ in range(12):
            h = np.tanh(Wx[c] + Wh @ h + bh); z = Wy.T @ h + by; z -= z.max(); p = np.exp(z); p /= p.sum()
            c = rng.choice(V, p=p)
            if chars[c] == ".": break
            mot += chars[c]
        print(mot, end="  ")
    print()
generer_rnn()

Le gradient qui disparaît, encore

Pour relier la sortie au temps t à l’entrée au temps t − k, le gradient traverse k fois Wh et tanh′ (≤ 1) : il s’évanouit (ou explose) exponentiellement en k. Un RNN simple ne retient guère plus de 10-20 pas. Les LSTM (1997) et GRU ajoutent des « portes » qui laissent passer l’information sans la multiplier — ils ont dominé la traduction et la parole jusqu’en 2017. Mais ils restent séquentiels : impossible de paralléliser sur la longueur, donc lents à entraîner sur des milliards de mots. L’attention résout les deux problèmes.

03 / Attention

L’attention : chaque position interroge toutes les autres

import numpy as np
rng = np.random.default_rng(1)
# Une séquence de n = 6 positions, chacune un vecteur de dimension d = 8
n, d, dk = 6, 8, 4
X = rng.normal(0, 1, (n, d))
Wq, Wk, Wv = [rng.normal(0, 0.5, (d, dk)) for _ in range(3)]
Q, K, Vv = X @ Wq, X @ Wk, X @ Wv                      # requêtes, clés, valeurs : (n, dk)

scores = Q @ K.T / np.sqrt(dk)                          # (n, n) : à quel point la position i « cherche » la position j
def softmax(z): z = z - z.max(-1, keepdims=True); e = np.exp(z); return e / e.sum(-1, keepdims=True)
A = softmax(scores)                                     # chaque ligne somme à 1 : les poids d'attention
sortie = A @ Vv                                         # (n, dk) : chaque position = mélange pondéré des valeurs
print("poids d'attention (ligne = position qui regarde) :\n", A.round(2))

# Masque causal : pour un modèle de langue, la position t ne doit voir que les positions ≤ t
masque = np.tril(np.ones((n, n)))
A_causal = softmax(np.where(masque == 1, scores, -1e9))
print("\ncausale :\n", A_causal.round(2))
print("\ncoût : n² =", n * n, "scores ; pour n = 100 000 tokens de contexte :", 100_000**2 / 1e9, "milliards")

Lire l’attention comme une base de données floue

Chaque position émet une requête (« que cherche-je ? »), une clé (« que contiens-je ? ») et une valeur (« que transmets-je ? »). Le score requête·clé mesure la pertinence ; le softmax en fait des poids ; la sortie est la somme pondérée des valeurs. Contrairement au RNN, la position 100 accède à la position 1 en un pas, sans dégradation ; et tout se calcule par des produits matriciels parallèles. Le prix : n² scores. D’où les recherches sur l’attention linéaire, les fenêtres glissantes, FlashAttention (même calcul, mémoire optimisée) et les « états » façon RNN qui reviennent (Mamba) — un front de recherche actif.

03 / Attention

Multi-têtes, position, bloc transformeur

import numpy as np
def couche_norm(x, eps=1e-5): return (x - x.mean(-1, keepdims=True)) / np.sqrt(x.var(-1, keepdims=True) + eps)
def gelu(x): return 0.5 * x * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * x**3)))

class Attention:
    def __init__(self, d, tetes):
        self.h, self.dk = tetes, d // tetes
        self.Wqkv = rng.normal(0, 0.02, (d, 3 * d)); self.Wo = rng.normal(0, 0.02, (d, d))
    def __call__(self, X):
        n, d = X.shape
        qkv = X @ self.Wqkv; Q, K, Vv = np.split(qkv, 3, axis=1)
        Q, K, Vv = [m.reshape(n, self.h, self.dk).transpose(1, 0, 2) for m in (Q, K, Vv)]   # (têtes, n, dk)
        S = Q @ K.transpose(0, 2, 1) / np.sqrt(self.dk)
        S = np.where(np.tril(np.ones((n, n))) == 1, S, -1e9)                                # causal
        out = softmax(S) @ Vv                                                               # (têtes, n, dk)
        return out.transpose(1, 0, 2).reshape(n, d) @ self.Wo                               # concaténer les têtes

class Bloc:
    def __init__(self, d, tetes):
        self.att = Attention(d, tetes); self.W1 = rng.normal(0, 0.02, (d, 4 * d)); self.W2 = rng.normal(0, 0.02, (4 * d, d))
    def __call__(self, X):
        X = X + self.att(couche_norm(X))                          # attention + connexion résiduelle
        return X + gelu(couche_norm(X) @ self.W1) @ self.W2       # MLP par position + résiduel

d, tetes, n = 16, 4, 10
pos = rng.normal(0, 1, (n, d))                                    # plongements de position (appris ou sinusoïdaux)
X = rng.normal(0, 1, (n, d)) + pos
blocs = [Bloc(d, tetes) for _ in range(3)]
Y = X
for b in blocs: Y = b(Y)
print("entrée", X.shape, "→ sortie", Y.shape, "| paramètres par bloc :", sum(m.size for m in (blocs[0].att.Wqkv, blocs[0].att.Wo, blocs[0].W1, blocs[0].W2)))
print("GPT-2 : d = 768, 12 têtes, 12 blocs, contexte 1024 → 124 M paramètres. GPT-3 : d = 12288, 96 blocs → 175 G.")

Anatomie de GPT

Tokenisation (BPE) : le texte devient des entiers (morceaux de mots).
Plongement de token + plongement de position (sans lui, l’attention ne sait pas l’ordre : c’est un ensemble, pas une séquence).
N blocs : attention causale multi-têtes → MLP, chacun avec normalisation et résiduel.
Tête de sortie : projection vers le vocabulaire, softmax, entropie croisée sur le token suivant.

Les têtes multiples permettent d’attendre à plusieurs choses à la fois (syntaxe, coréférence, position). Le MLP « par position » stocke l’essentiel des connaissances factuelles. Les résiduels et la normalisation (module L14) rendent 96 blocs entraînables.

03 / Attention

Entraîner un mini-transformeur avec autodiff : générer des noms de robots

import numpy as np, math
rng = np.random.default_rng(2)
# Autodiff sur tableaux, version minimale (même idée que Val du module L12, mais avec NumPy)
class T:
    def __init__(self, v, parents=(), back=None): self.v = np.asarray(v, float); self.g = np.zeros_like(self.v); self.p = parents; self.back = back
    def __matmul__(a, b):
        r = T(a.v @ b.v, (a, b)); r.back = lambda: (a.g.__iadd__(r.g @ b.v.T), b.g.__iadd__(a.v.T @ r.g)); return r
    def __add__(a, b):
        r = T(a.v + b.v, (a, b))
        def bk():                                                  # gestion du broadcast d'un biais (d,) sur (n, d)
            a.g += r.g if a.v.shape == r.g.shape else r.g.sum(0)
            b.g += r.g if b.v.shape == r.g.shape else r.g.sum(0)
        r.back = bk; return r
    def gelu(a):
        t = np.tanh(0.7979 * (a.v + 0.044715 * a.v**3)); r = T(0.5 * a.v * (1 + t), (a,))
        r.back = lambda: a.g.__iadd__(r.g * (0.5 * (1 + t) + 0.5 * a.v * (1 - t**2) * 0.7979 * (1 + 3 * 0.044715 * a.v**2))); return r
    def norm(a):
        mu = a.v.mean(-1, keepdims=True); s = np.sqrt(a.v.var(-1, keepdims=True) + 1e-5); xh = (a.v - mu) / s; r = T(xh, (a,))
        r.back = lambda: a.g.__iadd__((r.g - r.g.mean(-1, keepdims=True) - xh * (r.g * xh).mean(-1, keepdims=True)) / s); return r
    def attention_causale(a, dk):
        n = len(a.v); Q, K, Vv = np.split(a.v, 3, axis=1); S = Q @ K.T / math.sqrt(dk)
        S = np.where(np.tri(n) == 1, S, -1e9); A = np.exp(S - S.max(1, keepdims=True)); A /= A.sum(1, keepdims=True)
        r = T(A @ Vv, (a,))
        def bk():
            dA = r.g @ Vv.T; dV = A.T @ r.g; dS = A * (dA - (dA * A).sum(1, keepdims=True)) / math.sqrt(dk)
            a.g += np.concatenate([dS @ K, dS.T @ Q, dV], axis=1)
        r.back = bk; return r
    def perte_softmax(a, y):
        z = a.v - a.v.max(1, keepdims=True); p = np.exp(z); p /= p.sum(1, keepdims=True)
        r = T(-np.log(p[np.arange(len(y)), y]).mean(), (a,))
        def bk(): d = p.copy(); d[np.arange(len(y)), y] -= 1; a.g += d / len(y)
        r.back = bk; return r
    def backward(self):
        ordre, vus = [], set()
        def visiter(n):
            if id(n) not in vus:
                vus.add(id(n)); [visiter(p) for p in n.p]; ordre.append(n)
        visiter(self); self.g = np.ones_like(self.v)
        for n in reversed(ordre):
            if n.back: n.back()

d, L = 24, 12                                              # dimension, longueur de contexte
params = {"E": T(rng.normal(0, 0.5, (V, d))), "P": T(rng.normal(0, 0.5, (L, d))),
          "Wqkv": T(rng.normal(0, 0.2, (d, 3 * d))), "Wo": T(rng.normal(0, 0.2, (d, d))),
          "W1": T(rng.normal(0, 0.2, (d, 4 * d))), "b1": T(np.zeros(4 * d)), "W2": T(rng.normal(0, 0.2, (4 * d, d))), "Wy": T(rng.normal(0, 0.2, (d, V)))}
def modele(seq):
    n = len(seq); x = T(params["E"].v[seq] + params["P"].v[:n], (params["E"], params["P"]))
    def bk(): np.add.at(params["E"].g, seq, x.g); params["P"].g[:n] += x.g
    x.back = bk
    x = x + (x.norm() @ params["Wqkv"]).attention_causale(d) @ params["Wo"]
    x = x + ((x.norm() @ params["W1"] + params["b1"]).gelu() @ params["W2"])
    return x.norm() @ params["Wy"]
m = {k: np.zeros_like(p.v) for k, p in params.items()}; v = {k: np.zeros_like(p.v) for k, p in params.items()}; t = 0
seqs = [[idx[c] for c in "." + nom + "."][:L + 1] for nom in NOMS]
for epoch in range(25):
    total = 0
    for s in rng.permutation(len(seqs)):
        seq = seqs[s]; perte = modele(seq[:-1]).perte_softmax(np.array(seq[1:])); total += perte.v
        for p in params.values(): p.g[...] = 0
        perte.backward(); t += 1
        for k, p in params.items():                                    # Adam
            m[k] = 0.9 * m[k] + 0.1 * p.g; v[k] = 0.999 * v[k] + 0.001 * p.g**2
            p.v -= 3e-3 * (m[k] / (1 - 0.9**t)) / (np.sqrt(v[k] / (1 - 0.999**t)) + 1e-8)
    if epoch % 5 == 4: print(f"epoch {epoch + 1}: perte {total / len(seqs):.3f}")

for _ in range(10):
    seq = [idx["."]]
    for _ in range(L):
        z = modele(seq).v[-1]; p = np.exp(z - z.max()); p /= p.sum(); c = rng.choice(V, p=p)
        if chars[c] == ".": break
        seq.append(c)
    print("".join(chars[i] for i in seq[1:]), end="  ")
print()

Un transformeur complet — plongements, position, attention causale, MLP, normalisations, résiduels, Adam — en 60 lignes, avec ses gradients dérivés à la main (l’attention et la normalisation sont les deux dérivations délicates : comparez-les aux formules des modules L14 et L12). La perte descend, les noms générés ressemblent aux noms d’entraînement sans les copier. GPT-2 est ce code avec d = 768, 12 blocs et 40 Go de texte.

04 / Les grands modèles

Du transformeur à l’assistant : pré-entraînement, ajustement, RLHF

Étape	Données	Objectif	Résultat
1. Pré-entraînement	Des milliers de milliards de tokens (web, livres, code)	Prédire le token suivant	Un modèle « de base » qui complète du texte, sait beaucoup, mais n’obéit pas
2. Ajustement supervisé (SFT)	Dizaines de milliers de dialogues écrits par des humains	Imiter les réponses	Un modèle qui répond aux instructions
3. Apprentissage par préférences (RLHF / DPO)	Paires de réponses classées par des humains	Maximiser la préférence humaine (module L16)	Un assistant utile, honnête, inoffensif — en principe

Lois d’échelle et émergence

Kaplan (2020) et Hoffmann (« Chinchilla », 2022) ont montré que la perte suit des lois de puissance en fonction des paramètres, des données et du calcul, et qu’il faut ≈ 20 tokens par paramètre pour un entraînement efficace. Des capacités (arithmétique à plusieurs chiffres, raisonnement en chaîne) apparaissent à certaines tailles sans avoir été programmées — « émergence », dont la réalité statistique est débattue. Coût : GPT-4 ≈ 10²⁵ opérations, des dizaines de millions de dollars et des mégawatts. Sur votre PC : un modèle de 7 milliards de paramètres quantifié en 4 bits tourne sur une carte graphique grand public (llama.cpp).

Ce qu’un LLM ne fait pas

Il ne « sait » pas ce qui est vrai : il produit le token le plus probable. D’où les hallucinations, réduites mais pas éliminées par RLHF et la recherche documentaire (RAG).
Il ne calcule pas : l’arithmétique est apprise par cœur, mal ; d’où l’appel à des outils (calculatrice, Python) — ce que fait cet assistant que vous utilisez.
Son contexte est fini (n² oblige) ; il n’a pas de mémoire entre les conversations sauf si on la lui donne.
Ses biais sont ceux de ses données ; son « alignement » est un problème de recherche ouvert (module L24).

04 / Les grands modèles

Au-delà du texte : vision, robotique, modèles génératifs

import numpy as np
# Vision Transformer (ViT) : découper l'image en patchs, chaque patch = un « token ». Plus de convolution.
img = rng.random((32, 32)); P = 8
patchs = img.reshape(32 // P, P, 32 // P, P).transpose(0, 2, 1, 3).reshape(-1, P * P)
print("image 32×32 →", patchs.shape[0], "patchs de", patchs.shape[1], "valeurs = une séquence de 16 tokens")

# Diffusion (DALL·E, Stable Diffusion) : apprendre à débruiter. Illustration 1D : ajouter du bruit par étapes
x0 = np.sin(np.linspace(0, 6, 50))                          # une « donnée »
betas = np.linspace(1e-3, 0.2, 20); alphas_cum = np.cumprod(1 - betas)
for t in (0, 5, 19):
    xt = np.sqrt(alphas_cum[t]) * x0 + np.sqrt(1 - alphas_cum[t]) * rng.normal(0, 1, 50)
    print(f"étape {t:2d}: signal restant {np.sqrt(alphas_cum[t]):.2f}, corrélation avec x0 {np.corrcoef(x0, xt)[0, 1]:.2f}")
print("Un réseau apprend à prédire le bruit ajouté ; générer = partir du bruit pur et débruiter 20 à 1000 fois.")

# Robotique : les « politiques » (module L16) deviennent des transformeurs qui lisent images + langage et sortent des commandes
print("RT-2, OpenVLA, π0 : entrée = images caméra + instruction (« range la tasse ») ; sortie = tokens d'actions (positions des articulations).")

Le transformeur est devenu l’architecture universelle : texte (GPT), images (ViT, DALL·E), son (Whisper), protéines (AlphaFold 2), jeux (AlphaStar), robots (RT-2). La raison profonde : c’est un opérateur générique sur des ensembles de vecteurs, qui apprend lui-même quelles relations comptent. Comprendre ses limites — et ce qui viendra après — est l’un des sujets de recherche les plus actifs au monde.

Cours

Cours 1 — Modèles de langue : définition, factorisation, évaluation

Définition. Un modèle de langue attribue une probabilité à toute suite de tokens x₁…x_T. Par la règle de la chaîne (probabilités, L11), P(x_1..T) = Π_t P(x_t | x_1..t−1) : il suffit de modéliser « le suivant sachant le passé ». Un modèle n-gramme tronque le passé aux n−1 derniers tokens (Markov d’ordre n−1) ; un réseau récurrent le résume dans un état ; un transformeur regarde tout le contexte (borné par la fenêtre).

Mesure	Formule	Interprétation
Entropie croisée	H = −(1/T) Σ log₂ P(x_t \| passé)	Bits par token ; ce qu’on minimise à l’entraînement
Perplexité	2^H (ou e^H en nats)	« Nombre de choix équiprobables équivalent » ; uniforme sur V tokens : V
Repères	GPT-2 : ≈ 20-30 de perplexité par mot sur WikiText ; humains ≈ 10-12	Plus bas = meilleur ; dépend du tokeniseur et du corpus, donc à comparer à tokeniseur égal

Échantillonner. À la génération, tirer selon P (température 1), ou aplatir/aiguiser avec une température τ : P ∝ exp(logits/τ) — τ → 0 : argmax (déterministe, répétitif) ; τ > 1 : plus créatif, plus d’erreurs. Top-k / top-p : ne tirer que parmi les k meilleurs / la masse p. Ces réglages expliquent le comportement des assistants IA.

Cours

Cours 2 — Exemple travaillé : dériver la passe arrière de l’attention

Avant. S = QKᵀ/√d, A = softmax(S) (par ligne), O = AV. Notons dO = ∂J/∂O (donné par la couche suivante).

Traverser O = AV : dA = dO Vᵀ, dV = Aᵀ dO (règles de la couche affine, L14).
Traverser le softmax par ligne : pour une ligne a = softmax(s), la jacobienne est diag(a) − a aᵀ, donc dS = a ⊙ (dA − ⟨dA, a⟩) — le terme ⟨dA, a⟩ = Σ_j dA_j a_j est soustrait à toute la ligne. En matrices : dS = A ⊙ (dA − rowsum(dA ⊙ A)).
Traverser S = QKᵀ/√d : dQ = dS K/√d, dK = dSᵀ Q/√d.
Masque causal : les positions masquées ont a = 0, donc dS = 0 : rien à faire de plus.

Vérification (comme toujours) par différences finies sur une petite matrice — c’est exactement ce que fait la cellule du mini-transformeur du cours (méthode attention_causale). Coût : mêmes produits n×n que l’avant ; mémoire O(n²) pour stocker A — d’où FlashAttention, qui recalcule A par blocs dans la passe arrière plutôt que de la garder.

Cours

Cours 3 — Utiliser un LLM comme composant : API, prompts, RAG, agents, évaluation

Technique	Principe	Quand	Piège
Prompt structuré	Rôle, tâche, format de sortie (JSON), exemples (few-shot)	Toujours	Ambiguïté → réponses variables ; tester sur 50 cas
Chaîne de pensée	Demander les étapes avant la réponse	Raisonnement, calcul	Plus long, plus cher ; les étapes peuvent être fausses mais la réponse juste, et l’inverse
RAG	Chercher des documents (plongements + similarité cosinus) et les mettre dans le contexte	Connaissances privées ou récentes	Qualité de la recherche ; le modèle peut ignorer ou contredire le contexte
Outils / fonctions	Le modèle émet un appel (calculatrice, SQL, API du robot), le programme l’exécute et renvoie le résultat	Calcul exact, actions	Valider chaque appel avant exécution ; jamais d’action irréversible sans confirmation
Agent	Boucle observer → réfléchir → agir, avec mémoire	Tâches multi-étapes	Boucles infinies, coûts, dérive ; borner le nombre d’étapes
Ajustement (fine-tuning, LoRA)	Réentraîner quelques paramètres sur vos données	Style, format, domaine étroit	Coût, données étiquetées, oubli
Évaluation	Jeu de test avec réponses attendues ; métriques automatiques + relecture humaine ; LLM-juge avec prudence	Avant tout déploiement	Contamination (le test est dans les données d’entraînement)

Règle pour un robot piloté par LLM : le modèle propose, un programme classique vérifie (plage des commandes, sécurité, L21) et exécute. Le LLM n’est jamais dans la boucle de sécurité.

TP guidé

TP — nanoGPT sur vos propres textes, puis un modèle local avec outils (sur PC, 3 h)

Corpus. Un fichier texte de 1 à 5 Mo : vos notes de cours, un livre du domaine public (Gutenberg), des paroles… wc -c corpus.txt. Tokeniseur caractère (L15) puis BPE maison (défi ★) : comparez le nombre de tokens.
nanoGPT. git clone https://github.com/karpathy/nanoGPT ; suivez le README « quick start » (Shakespeare caractère) ; entraînez 5 minutes sur CPU (--device=cpu --compile=False, blocs et couches réduits). Lisez model.py ligne à ligne : retrouvez CausalSelfAttention, MLP, Block, les plongements de position — exactement le mini-transformeur du cours, en PyTorch.
Votre corpus. Adaptez data/ ; entraînez ; échantillonnez avec plusieurs températures ; mesurez la perplexité sur une partie tenue à l’écart. Faites varier une chose à la fois (taille du contexte, nombre de têtes, dimension) et notez la perte de validation.
Modèle local. Installez Ollama (ou llama.cpp) et un modèle ouvert de 3 à 8 milliards de paramètres. Mesurez tokens/s. Écrivez un script Python qui l’interroge via son API HTTP (L08) : prompt structuré, sortie JSON, 20 questions de test avec réponses attendues, taux de réussite.
Outils. Ajoutez deux « outils » : une calculatrice et une fonction etat_robot() (simulée). Le modèle doit répondre par un appel JSON {"outil": …, "args": …} que votre programme exécute, puis renvoyer le résultat au modèle. Testez : « quelle est la distance du robot au mur multipliée par 3 ? ». Comptez les échecs de format et ajoutez une validation + une relance.
Livrable. Dépôt : corpus (ou lien), configuration nanoGPT, courbes de perte, échantillons commentés, script d’évaluation du modèle local avec taux de réussite, et une page « ce que le modèle fait bien / mal et pourquoi (taille de contexte, tokenisation, connaissances) ».

Exercices

Exercices auto-corrigés — modèles de langue

Exercice 1 — Trigramme lissé et perplexité

Écrivez Trigramme : entraînement par comptage sur des mots (préfixe de deux tokens « <s> <s> », fin « </s> »), probabilité avec lissage additif α, log_prob(phrase) et perplexite(phrases) (en base e, par token, fin de phrase comprise). Vérifiez que la perplexité sur le corpus d’entraînement est plus basse que sur des phrases nouvelles, et qu’un α plus grand la rapproche de |V|.

Correction

class Trigramme:
    def __init__(self, phrases, alpha=0.1):
        self.alpha = alpha; self.c3 = Counter(); self.c2 = Counter(); self.vocab = {"</s>"}
        for ph in phrases:
            t = ["<s>", "<s>"] + ph.split() + ["</s>"]; self.vocab |= set(t[2:])
            for a, b, c in zip(t, t[1:], t[2:]): self.c3[(a, b, c)] += 1; self.c2[(a, b)] += 1
    def prob(self, w1, w2, w3): return (self.c3[(w1, w2, w3)] + self.alpha) / (self.c2[(w1, w2)] + self.alpha * len(self.vocab))
    def log_prob(self, phrase):
        t = ["<s>", "<s>"] + phrase.split() + ["</s>"]
        return sum(math.log(self.prob(a, b, c)) for a, b, c in zip(t, t[1:], t[2:]))
    def perplexite(self, phrases):
        n = sum(len(p.split()) + 1 for p in phrases); return math.exp(-sum(self.log_prob(p) for p in phrases) / n)

Exercice 2 — Plongements de position sinusoïdaux et attention relative

a) positions_sinus(n, d) : la matrice de l’article (« Attention Is All You Need », §3.5) : PE[pos, 2i] = sin(pos/10000^2i/d), PE[pos, 2i+1] = cos(…). b) Montrez numériquement que PE[pos+k] est une fonction linéaire de PE[pos] pour k fixé : pour chaque paire (2i, 2i+1), une rotation de l’angle k·ω_i. Écrivez decaler(PE_pos, k, d) qui applique ces rotations et vérifiez qu’on retrouve PE[pos+k].

Correction

def positions_sinus(n, d):
    pos = np.arange(n)[:, None]; i = np.arange(0, d, 2)[None, :]; ang = pos / 10000 ** (i / d)
    PE = np.zeros((n, d)); PE[:, 0::2] = np.sin(ang); PE[:, 1::2] = np.cos(ang); return PE
def decaler(pe, k, d):
    out = pe.copy()
    for j, i in enumerate(range(0, d, 2)):
        w = 1 / 10000 ** (i / d); c, s = np.cos(k * w), np.sin(k * w)
        sn, cs = pe[i], pe[i + 1]
        out[i], out[i + 1] = sn * c + cs * s, cs * c - sn * s          # sin(a+b), cos(a+b)
    return out

Exercices

Exercices auto-corrigés — attention et génération

Exercice 3 — Attention multi-têtes avec masque de remplissage (padding)

Dans un lot, les séquences ont des longueurs différentes : on complète par des tokens de remplissage qui ne doivent recevoir aucune attention. Écrivez attention_multi(X, Wq, Wk, Wv, Wo, h, masque) où masque (n,) vaut True pour les positions réelles : les colonnes de remplissage reçoivent −∞ avant le softmax. Vérifiez que la sortie des positions réelles ne change pas quand on modifie les vecteurs des positions de remplissage.

Correction

def attention_multi(X, Wq, Wk, Wv, Wo, h, masque):
    n, d = X.shape; dk = d // h
    Q, K, V = [(X @ Wm).reshape(n, h, dk).transpose(1, 0, 2) for Wm in (Wq, Wk, Wv)]
    S = Q @ K.transpose(0, 2, 1) / np.sqrt(dk); S = np.where(masque[None, None, :], S, -1e9)
    A = np.exp(S - S.max(-1, keepdims=True)); A /= A.sum(-1, keepdims=True)
    return (A @ V).transpose(1, 0, 2).reshape(n, d) @ Wo

Exercice 4 — Recherche en faisceau (beam search)

Avec le modèle Trigramme de l’exercice 1, écrivez beam_search(modele, largeur, max_len) qui génère la phrase la plus probable (log-prob totale) en gardant à chaque étape les largeur meilleures hypothèses ; comparez à la génération gloutonne (largeur 1). Une hypothèse est terminée quand elle émet </s>.

Correction

def beam_search(m, largeur=3, max_len=8):
    faisceau = [(["<s>", "<s>"], 0.0)]; finis = []
    for _ in range(max_len + 1):
        cand = []
        for seq, lp in faisceau:
            for w in m.vocab:
                p = lp + math.log(m.prob(seq[-2], seq[-1], w))
                if w == "</s>": finis.append((seq[2:], p))
                else: cand.append((seq + [w], p))
        faisceau = sorted(cand, key=lambda c: -c[1])[:largeur]
        if not faisceau: break
    return max(finis, key=lambda c: c[1])

05 / Défis

Défi ★ — Tokenisation BPE

Consigne

Implémentez l’algorithme Byte-Pair Encoding : partir des caractères, fusionner itérativement la paire adjacente la plus fréquente en un nouveau token, 30 fois, sur le corpus de noms. Affichez le vocabulaire obtenu et la tokenisation de « vortexon ». Puis encodez et décodez un texte : vérifiez que décoder(encoder(t)) == t. Pourquoi les LLM comptent-ils mal les lettres d’un mot ?

Correction (extrait)

from collections import Counter
mots = [list(m) + ["_"] for m in corpus.split()]
fusions = []
for _ in range(30):
    paires = Counter((a, b) for m in mots for a, b in zip(m, m[1:]))
    if not paires: break
    (a, b), _ = paires.most_common(1)[0]; fusions.append((a, b))
    mots = [[*m] for m in mots]
    for m in mots:
        i = 0
        while i < len(m) - 1:
            if m[i] == a and m[i + 1] == b: m[i:i + 2] = [a + b]
            else: i += 1
def encoder(texte):
    m = list(texte)
    for a, b in fusions:
        i = 0
        while i < len(m) - 1:
            if m[i] == a and m[i + 1] == b: m[i:i + 2] = [a + b]
            else: i += 1
    return m
print(fusions[:10]); print(encoder("vortexon"))

Un LLM voit « vortexon » comme [« vor », « tex », « on »] : il n’a jamais vu les lettres individuellement, d’où ses difficultés à compter les « r » dans « strawberry » — une limite d’interface, pas d’intelligence.

05 / Défis

Défi ★★ — Visualiser l’attention et sonder le modèle

Consigne

1) Modifiez attention_causale pour stocker la matrice A ; après entraînement, affichez-la (imshow) pour le nom « pulsar » : quelles positions regardent quoi ? 2) Ajoutez une 2e tête d’attention (séparer Q, K, V en deux moitiés) et comparez les matrices des deux têtes. 3) « Sonde » linéaire : entraînez une régression logistique (module L13) sur les activations de la couche cachée pour prédire « la lettre courante est une voyelle » : le modèle a-t-il appris cette notion sans qu’on la lui donne ?

Piste

Pour 3) : collectez pour chaque (nom, position) le vecteur x.v après le bloc (24 dimensions) et l’étiquette voyelle/consonne de la lettre à cette position ; entraînez logistique ; une exactitude nettement supérieure à la fréquence des voyelles montre que l’information est linéairement décodable dans les représentations. C’est la méthode de l’interprétabilité mécanistique, un domaine de recherche jeune : comprendre ce que les modèles ont appris en lisant leurs activations (Anthropic, OpenAI, DeepMind y consacrent des équipes).

05 / Défis

Défi ★★★ — Esprit prépa : complexité, contexte long et le retour des récurrences

Consigne

1) Mesurez le temps de la passe avant de Attention pour n = 64, 128, 256, 512, 1024 : vérifiez le O(n²) (et O(n² d) en mémoire pour A). 2) Implémentez l’attention linéaire : remplacer softmax(QKᵀ)V par φ(Q)(φ(K)ᵀV) avec φ(x) = elu(x) + 1 ; montrez que le coût devient O(n d²) et que, en causal, elle s’écrit comme une récurrence (un « état » d × d mis à jour à chaque token — exactement un RNN !). 3) Comparez la qualité (perte) sur les noms de robots avec l’attention softmax. 4) Lisez le résumé de « Mamba » (Gu & Dao, 2023) ou de « RWKV » et expliquez en quoi ces modèles sont des RNN qui s’entraînent comme des transformeurs. Quel est l’enjeu pour un robot qui doit traiter un flux de capteurs de plusieurs heures ?

Correction (extrait : attention linéaire causale comme récurrence)

def phi(x): return np.where(x > 0, x, np.exp(x) - 1) + 1          # elu + 1 > 0
def attention_lineaire_causale(Q, K, Vv):
    n, dk = Q.shape; S = np.zeros((dk, Vv.shape[1])); z = np.zeros(dk); out = np.zeros_like(Vv)
    for t in range(n):                                                # récurrence : état S (dk × dv), normaliseur z
        S += np.outer(phi(K[t]), Vv[t]); z += phi(K[t])
        out[t] = phi(Q[t]) @ S / (phi(Q[t]) @ z + 1e-9)
    return out
n, dk = 8, 4; Q, K, Vv = [rng.normal(0, 1, (n, dk)) for _ in range(3)]
# Version « parallèle » équivalente pour vérifier (masque causal explicite)
A = np.tril(phi(Q) @ phi(K).T); A /= A.sum(1, keepdims=True)
print(np.allclose(A @ Vv, attention_lineaire_causale(Q, K, Vv)))

L’état S résume tout le passé en d×d nombres : coût constant par token, contexte illimité — comme un RNN — mais entraînable en parallèle par la forme matricielle. Le prix est une capacité de « rappel exact » plus faible que le softmax (qui peut pointer précisément une position). Pour un robot, un modèle à état constant est la seule option pour un flux continu ; c’est pourquoi ces architectures (SSM, Mamba, xLSTM) sont très étudiées en robotique et en traitement du signal. Question ouverte : quelle est la bonne combinaison ?

06 / Vérification

Pourquoi un transformeur a-t-il besoin de plongements de position ?

Deux questions supplémentaires

1. Pourquoi le RNN oublie-t-il les positions lointaines ? Le gradient traverse k multiplications par Wh et tanh′ : il décroît exponentiellement en k.

2. Que mesure la perplexité ? exp de l’entropie croisée moyenne : le nombre effectif de choix entre lesquels le modèle hésite à chaque token.

Référence

Les mots à retenir

Mot	Définition
Modèle de langue	P(token suivant \| contexte).
Perplexité	exp(entropie croisée moyenne).
Token / BPE	Unité de texte ; fusions de paires fréquentes.
Plongement	Vecteur appris par symbole.
RNN / LSTM	État récurrent ; portes contre l’oubli.
Attention (Q, K, V)	softmax(QKᵀ/√d)V ; O(n²).
Masque causal	Interdire de voir le futur.
Multi-têtes	Plusieurs attentions en parallèle, concaténées.
Bloc transformeur	Attention + MLP, avec normalisation et résiduels.
SFT / RLHF	Ajustement supervisé / par préférences humaines.
Lois d’échelle	Perte en loi de puissance du calcul, des données, des paramètres.
Attention linéaire / SSM	Coût linéaire, forme récurrente.

Pour continuer

Vous savez ce qu’il y a dans un LLM

Module suivant : l’apprentissage par renforcement — apprendre par essais et récompenses : bandits, Q-learning, gradient de politique, et le lien avec la robotique et le RLHF.

À faire chez soi

Suivre « Let’s build GPT: from scratch, in code, spelled out » (Karpathy, 2 h) en codant en PyTorch.
Lire « Attention Is All You Need » (10 pages) et « The Illustrated Transformer ».
Faire tourner un modèle ouvert (Llama, Mistral, Qwen) en local avec llama.cpp ou Ollama ; mesurer sa perplexité sur un texte de votre choix.

← L14 Sommaire L16 : Apprentissage par renforcement →