Construire un Transformer depuis zéro

Un bloc Transformer, c'est six petites opérations empilées dans un ordre précis. La plupart des explications sautent l'assemblage. Ce guide construit chaque pièce isolément — attention, multi-têtes, résidus, LayerNorm, feed-forward — puis les réunit dans un modèle PyTorch fonctionnel. Trois chapitres exécutables soutiennent cette page.

1. Le Transformer en une phrase

Le Transformer est une pile de blocs identiques. Chaque bloc laisse chaque token de la séquence regarder tous les autres (via l'attention), puis traite chaque token indépendamment (via un réseau feed-forward). Les connexions résiduelles et la LayerNorm maintiennent la circulation des gradients quand la pile devient profonde.

2. La tête d'attention

La version la plus simple de l'attention prend trois projections de l'entrée — Query, Key, Value — et calcule une somme pondérée des values. Les poids viennent de la correspondance entre chaque query et chaque key.

La formule exacte :

A = softmax(Q · Kᵀ / √d_k) · V

Le chapitre 8 — une tête d'attention à la main construit cette opération étape par étape, avec des visualisations interactives de la matrice d'attention et du masque causal.

3. L'attention multi-têtes

Une fois qu'on a une tête, le multi-têtes est l'extension évidente : lancer plusieurs têtes en parallèle, chacune avec ses propres projections Q/K/V, puis concaténer leurs sorties et les reprojeter à travers une matrice apprise W_O.

Les têtes se spécialisent. Certaines regardent le token précédent (syntaxe). D'autres regardent un mot précis ailleurs dans la séquence (sémantique). D'autres regardent uniformément (identité). Le modèle n'a pas besoin qu'on lui dise laquelle fait quoi : il apprend le routage par les gradients.

Le chapitre 9 — multi-têtes et résidus déroule la découpe en têtes, la concaténation, et la connexion résiduelle qui rend toute la pile entraînable.

4. Résidus et LayerNorm

Deux pièces de plomberie gardent le Transformer entraînable en profondeur.

• Les connexions résiduelles : output = input + sublayer(input). Le bloc apporte un delta à l'entrée au lieu de la remplacer. Les gradients traversent l'addition proprement ; la profondeur cesse d'être un goulot d'étranglement.
• La LayerNorm : elle normalise le vecteur d'activation de chaque token à moyenne 0 et écart-type 1. Elle stabilise l'échelle des activations à mesure que la pile grandit. Les Transformers modernes appliquent la LayerNorm avant l'attention et le feed-forward (la variante « pre-norm »), plus stable que le post-norm de l'article d'origine.

Les deux sont couverts au chapitre 9, avec des visualisations comparant les gradients avant et après entraînement.

5. Le réseau feed-forward

Une fois que l'attention a fait son routage, chaque token est traité indépendamment par un petit MLP — deux couches linéaires séparées par une non-linéarité, en général GELU. C'est là que vit la majorité des paramètres du modèle en pratique : la dimension cachée du FFN vaut typiquement 4 fois la dimension du modèle.

6. Le bloc complet

En rassemblant tout, un bloc Transformer s'écrit :

x = x + Attention(LayerNorm(x))    # résidu d'attention
x = x + FFN(LayerNorm(x))          # résidu feed-forward

C'est tout. Empile N de ces blocs (12 pour GPT-2 small, 96 pour GPT-3) et tu as un Transformer.

Le chapitre 10 — le bloc Transformer complet assemble le bloc de bout en bout et fait tourner une passe avant avec les formes tracées proprement.

7. La suite

• En entraîner un : le chapitre 12 — le code minimal réécrit la même architecture en ~150 lignes de PyTorch ; le chapitre 13 — la boucle d'entraînement l'entraîne.
• Charger de vrais poids : le chapitre 15 fait correspondre les noms de paramètres de GPT-2 124M au modèle que tu as écrit.
• Le fine-tuner : le chapitre 17 — instruction tuning et le chapitre 18 — fine-tuning LoRA transforment le modèle de base en quelque chose d'utile.