Le bloc transformer complet

Tu as toutes les pièces. Assemblons la vraie chose.

Un bloc transformer est l’unité qu’on empile pour faire un transformer. Chaque bloc fait deux choses, dans l’ordre :

1. Attention multi-têtes — laisser chaque token regarder tous les autres tokens.
2. Réseau feed-forward (FFN) — traiter la représentation de chaque token indépendamment.

Les deux sont emballés dans la machinerie résiduelle + LayerNorm du chapitre 9. La sortie du bloc a la même forme que son entrée, et c’est précisément ce qui permet d’empiler des blocs identiques.

Ce chapitre a trois cellules exécutables : construire le FFN, assembler un bloc, puis empiler deux blocs et ajouter une unembedding pour obtenir une passe avant complète. Ensuite tu créeras le premier llm/model.py de ton dépôt local. Il restera minuscule et surtout occupé à vérifier des formes, mais il ressemblera enfin à un modèle de langage.

Même phrase jouet qu’aux chapitres 8 et 9. d_model = 8, n_heads = 4, ffn_hidden = 16, n_blocks = 2, vocab_size = 5. Minuscule — mais l’architecture est la même que celle de GPT.

1. Le réseau feed-forward

Chaque bloc transformer contient un MLP par token, qui tourne indépendamment sur la représentation de chacun. Il a deux couches linéaires séparées par une non-linéarité :

La dimension cachée ffn_hidden vaut d’habitude 4 × d_model (le FFN a donc bien plus de paramètres que la sous-couche d’attention). La non-linéarité GELU est la descendante lisse de ReLU qu’utilisent les transformers modernes ; on te la fournit.

Point crucial : le FFN ne laisse pas les tokens se voir entre eux. Le seul mélange entre tokens dans un bloc transformer, c’est l’attention. Le rôle du FFN est de réfléchir à ce que l’attention est allée chercher.

// FFN: two linear layers with a GELU non-linearity in between.
//   h = gelu(x · W1 + b1)        shape [seq_len × ffn_hidden]
//   out = h · W2 + b2            shape [seq_len × d_model]
// The script defines gelu(x).
return x;

La sortie a la même forme que l’entrée — toujours [seq_len × d_model]. C’est le contrat que respecte chaque sous-couche d’un transformer.

2. Le bloc complet

Compose maintenant l’attention et le FFN avec la recette résiduelle pre-norm :

Le chapitre câble l’attention multi-têtes et le FFN avec leurs poids déjà liés ; la cellule montre directement la composition.

// Pre-norm transformer block forward:
//   1. attention sublayer:  x' = x + attention(layerNorm(x))
//   2. FFN sublayer:        x'' = x' + ffn(layerNorm(x'))
// The script defines attention, ffn, and layerNorm above.
return x;

C’est tout le bloc transformer. S’il fonctionne, c’est grâce à la combinaison de trois propriétés : le flux résiduel garde une échelle constante (LayerNorm + addition), l’attention laisse l’information circuler entre positions, et le FFN laisse chaque position réfléchir à cette information de son côté.

3. Empiler les blocs + unembedding

L’architecture transformer n’est que N blocs à la suite, avec une LayerNorm finale et une matrice d’unembedding qui projette le dernier état caché vers des logits sur le vocabulaire.

La sortie est [seq_len × vocab_size]. Une ligne de logits par position d’entrée. Pour la génération autorégressive, on échantillonne depuis le softmax de la dernière ligne.

// Full transformer forward pass:
//   1. Apply each block in sequence: h = block(h, i) for i in 0..blocks.length-1.
//   2. Final LayerNorm.
//   3. Unembedding: multiply by 'unembedding' to get [seq_len × vocab_size] logits.
return x;

Ça, c’est un transformer. Le modèle a des poids aléatoires, donc le graphe en barres du bas ne veut rien dire — mais la forme est la bonne. Un vrai LLM, c’est cette même architecture avec quelques corrections (masquage causal, encodage positionnel, des nombres beaucoup plus grands) entraînée sur des milliards de tokens de texte.

Ce qu’on a laissé de côté

Un vrai transformer aurait aussi :

• Des embeddings de tokens. On est parti de X comme s’il était déjà embarqué. Un vrai modèle commence par aller chercher la ligne de chaque token dans une matrice d’embedding.
• Un encodage positionnel (ou RoPE). L’attention est équivariante par permutation : sans information de position, le modèle ne distingue pas the cat sat de sat cat the. Les vrais modèles ajoutent ou entrelacent un signal de position.
• Le masquage causal. Dans un transformer décodeur seul (façon GPT), le token i n’a pas le droit de regarder les tokens j > i pendant l’entraînement. On l’implémente en mettant les scores des positions futures à −∞ avant le softmax.
• Du dropout pendant l’entraînement.
• Des paramètres de LayerNorm (γ, β) appris, et non figés à 0 et 1.

La plupart de ces ajouts tiennent en une ligne. Aucun ne change la forme de l’architecture. Ce que tu viens de construire est le cœur ; le reste est de la plomberie.

4. Créer ton premier squelette de modèle

Crée llm/model.py :

"""A tiny GPT-shaped model skeleton.
 
Chapter 12 replaces the list math with PyTorch tensors. The architecture stays:
token embedding, position embedding, transformer blocks, final logits.
"""
from __future__ import annotations
 
from llm.attention import Matrix, causal_attention, matmul
from llm.nn import add, layer_norm, linear, relu
 
 
# [1]
def feed_forward(x: Matrix, w1: Matrix, b1: list[float], w2: Matrix, b2: list[float]) -> Matrix:
    return [linear(relu(linear(row, w1, b1)), w2, b2) for row in x]
 
 
def transformer_block(
    x: Matrix,
    wq: Matrix,
    wk: Matrix,
    wv: Matrix,
    ffn_w1: Matrix,
    ffn_b1: list[float],
    ffn_w2: Matrix,
    ffn_b2: list[float],
) -> Matrix:
    # [2]
    attended = causal_attention(layer_norm(x), wq, wk, wv)
    # [3]
    x = add(x, attended)
    # [4]
    return add(x, feed_forward(layer_norm(x), ffn_w1, ffn_b1, ffn_w2, ffn_b2))
 
 
# [5]
def logits(hidden: Matrix, unembed: Matrix) -> Matrix:
    return matmul(layer_norm(hidden), unembed)

Ce squelette est une carte du modèle complet :

• [1] feed_forward applique le même MLP à chaque ligne de token. Il ne mélange pas les positions ; l’attention l’a déjà fait.
• [2] ouvre le bloc par l’attention pre-norm : normaliser d’abord, puis router l’information entre tokens.
• [3] réinjecte la mise à jour de l’attention dans le flux résiduel.
• [4] répète le même motif avec le réseau feed-forward : normaliser, transformer, réinjecter.
• [5] logits convertit les vecteurs cachés en scores sur le vocabulaire. Une ligne de logits veut dire « les scores de chaque token suivant possible, à cette position ».

Ce fichier est volontairement incomplet : pas d’initialisation apprise, pas d’entraînement, pas de batch. Son rôle est de rendre l’architecture concrète avant que la version PyTorch n’en fasse quelque chose de rapide et d’entraînable.

Pour aller plus loin

• Vaswani et al., « Attention Is All You Need » (2017). Le papier complet du transformer.
• « Let’s build GPT from scratch » de Karpathy — construit le même modèle de bout en bout en PyTorch.
• The Annotated Transformer — implémentation ligne par ligne du papier, avec chaque modification explicitée.
• Step by Token, chapitre 5 traite le transformer sous l’angle de la compréhension.

Prochaine étape : c’est la fin de la partie III. La partie IV commence avec préparer un dataset — ton projet local existe déjà, il est temps de lui donner de vraies données.