Comment fonctionnent les Transformers, des goulets d’étranglement des RNN à l’attention, aux agents et aux fenêtres de contexte
Une visite pas à pas du transformateur : pourquoi les RNN ont stagné, comment fonctionnent les tokens et les embeddings, l’attention, QKV, les têtes de sortie, les positions, la structure en blocs, l’échelle et les agents.
Tout ceux qui n’utilisent que des outils d’IA peuvent s’en sortir sans comprendre ce qui se passe en arrière-plan. Ceux qui souhaitent développer, déboguer ou améliorer ces systèmes, en revanche, ne le peuvent pas. Chaque grand modèle de langage couramment utilisé repose sur une architecture présentée dans un article de 2017 d’environ quinze pages intitulé « Attention Is All You Need ». Peu d’articles de recherche de la dernière décennie ont autant changé la direction de l’intelligence artificielle. Les idées qui sous-tendent cette architecture ne sont pas aussi intimidantes qu’elles en ont l’air, et les calculs deviennent compréhensibles lorsqu’ils sont effectués dans le bon ordre. Par la suite, ces mêmes idées apparaissent partout : dans la manière dont les agents planifient, dans les raisons pour lesquelles l’apprentissage contextuel fonctionne, dans les raisons pour lesquelles un modèle peut passer d’un sujet à un autre au cours d’une conversation, et dans les raisons pour lesquelles des fenêtres de contexte plus longues sont si importantes.
Le parcours présenté ci-dessous commence par l’ancienne approche séquentielle et les raisons de son échec, aborde ensuite la manière dont le texte se transforme en nombres, puis l’attention et la structure de bloc complet, pour finir par expliquer comment cette conception a évolué vers les modèles de langage et les agents d’aujourd’hui.
Pourquoi la lecture du texte mot par mot a buté sur un obstacle
Au préalable aux transformateurs, le traitement du langage était principalement assuré par des réseaux neuronaux récurrents, souvent abrégés en RNN. L’idée est simple : le réseau parcourt une séquence mot après mot et conserve un état caché qui représente un résumé continu de tout ce qui a été vu jusqu’alors.
Une image approximative : quelqu’un lit un roman mais ne garde qu’une seule note adhésive, et doit avancer page par page, sans jamais sauter en avant ou revenir en arrière. Après chaque phrase, la note est réécrite avec ce qui semble important, mais elle est de petite taille. Vers la page 300, presque rien de la page 1 n’a survécu. Il est également impossible de donner le chapitre deux à un ami pour qu’il le lise en même temps, car les notes du chapitre un doivent d’abord être terminées.
Cette séquence stricte entraîne deux problèmes de mise à l’échelle distincts.
Le premier est le gradient qui disparaît. L’entraînement ajuste les poids par rétropropagation, qui détermine dans quelle mesure chaque paramètre a contribué à l’erreur. Dans un RNN qui lit une longue séquence, ce signal doit voyager en arrière à travers chaque étape temporelle. Lorsqu’il atteint les premières étapes, il a souvent été réduit à presque rien, de sorte que le réseau ne peut pas vraiment apprendre à partir de ce que ces premiers mots ont fait.
Le deuxième problème est le goulot d’étranglement séquentiel. Il est impossible de calculer le résultat à la position n avant que la position n-1 ne soit traitée, car chaque étape consomme l’état caché précédent. Les GPU modernes sont conçus pour effectuer un grand nombre d’opérations en même temps, et les RNN ne leur offrent presque rien à faire en parallèle. Un document de 1 000 mots nécessite 1 000 étapes consécutives, le matériel restant pour l’essentiel inactif entre elles.
Le diagramme ci-dessous met en contraste les deux façons de gérer les tokens : d’un côté, un traitement un par un avec un état caché qui s’estompe progressivement, et de l’autre, chaque paire de tokens traitée en même temps :
╔══════════════════════════════════════════════════════════════════════════════╗
║ RNN vs TRANSFORMER: HOW TOKENS ARE PROCESSED ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ RNN ── Sequential (slow, forgets early context) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ║
║ │ │ │ │ │ │ ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ RNN │──▶│ RNN │─▶│ RNN │▶│ RNN │▶│ RNN │▶│ RNN │ ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ h₁ ──▶ h₂ ──▶ h₃ ──▶ h₄ ──▶ h₅ ──▶ h₆ ║
║ ║
║ Step 1 Step 2 Step 3 Step 4 Step 5 Step 6 (must wait!) ║
║ ⚠ "The" signal is diluted through 5 hops by the time we reach "mat" ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ TRANSFORMER ── Parallel (fast, every token sees all others) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ◀── ALL AT ONCE ║
║ │╲╲ │╲ ╲╲ │╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ │ ╲╲ │ ╲ ╲╲ │ ╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ ├───╫──┼───╫───┼───╫───┼────╫──┼────╫───┤ ← every token ║
║ │ ╱╱ │ ╱ ╱╱ │ ╱╱ ╱ │ ╱╱ │ ╱╱ │ attends to ║
║ │╱╱ │╱ ╱╱ │╱╱ ╱ │ ╱╱ │ ╱╱ │ every token ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ out │ │ out │ │ out │ │ out │ │ out │ │ out │ ← all computed ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ simultaneously ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ ✓ "The" has DIRECT connection to "mat" — no information decay ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ LEGEND: ──▶ sequential dependency ╲╱╱ all-pairs attention ║
║ h₁ hidden state ⚠ information bottleneck ║
╚══════════════════════════════════════════════════════════════════════════════╝
Les portes ont aidé, mais n’ont pas changé la nature du problème
Les réseaux à mémoire à court et long terme, introduits par Hochreiter et Schmidhuber en 1997, ont ajouté des portes permettant un contrôle explicite de ce qu’il fallait conserver, supprimer ou émettre à chaque étape. Ils ont fonctionné bien. Tout au long des années 2010, ils ont été utilisés pour la plupart des applications pratiques en NLP, y compris les premières traductions automatiques, l’analyse des sentiments et la génération de texte.
Ils sont restés séquentiels. Les dépendances à très longue portée restaient difficiles à gérer, et le matériel parallèle ne pouvait toujours pas être utilisé pleinement. Les LSTM n’ont échoué ni parce qu’ils modélisaient mal le langage, ni parce qu’ils ne pouvaient pas être échelonnés : l’augmentation des ressources informatiques apportait de moins en moins d’avantages, et pour dépasser cette limite, il fallait un style de calcul complètement différent.
De texte en nombres
Les réseaux neuronaux traitent des nombres et le langage est composé de mots, il faut donc effectuer une conversion avant que l’attention ne soit mise en œuvre. Cela nécessite deux étapes : la tokenisation et l’incorporation.
Tokenisation
La tokenisation transforme une chaîne de caractères en une séquence d’ID entiers tirés d’un vocabulaire fixe. Il faut d’abord comprendre que les tokens ne sont pas des mots. Les tokeniseurs modernes divisent le texte en fragments de sous-mots, généralement à l’aide de Byte-Pair Encoding ou WordPiece, et les résultats ressemblent à ceci :
"Hello world" → ["Hello", " world"] → [15496, 995]
"unbelievable" → ["un", "believ", "able"] → [256, 9391, 540]
"ChatGPT" → ["Chat", "G", "PT"] → [14126, 38, 2969]
"antidisestablishmentarianism" → ["ant", "idis", "est", "ablish", "ment", "ari", "an", "ism"]
Les mots fréquents disposent de leur propre token, tandis que les mots rares ou composés sont divisés en parties plus petites. Cela permet une couverture efficace avec un vocabulaire de taille gérable, puisqu’il n’est pas nécessaire d’avoir une entrée pour chaque mot possible. La taille du vocabulaire varie d’environ 30 000 pour BERT et 50 257 pour GPT-2 à plus de 100 000 dans les modèles récents.
Une conversion utile pour l’anglais : un token correspond à environ trois quarts d’un mot, ou un mot équivaut à environ 1,3 token. Un roman de 100 000 mots compte donc approximativement 133 000 tokens, ce qui est important lorsque des limites de fenêtre de contexte s’appliquent.
Embeddings
Une matrice d’incorporation, composée d’une ligne par entrée du vocabulaire et de d_model colonnes, associe chaque identifiant de token à un vecteur dense. Pour rechercher un token, il suffit de sélectionner sa ligne correspondante. L’identifiant 995, qui représente le mot « world », fait référence à la ligne 995 et renvoie des valeurs d’ordre d_model, telles que 0,24, -0,83, 0,17, etc., jusqu’à 0,91.
Ces lignes sont apprises au cours de l’entraînement, et une propriété utile émerge : les tokens ayant des significations similaires possèdent des vecteurs géométriquement proches les uns des autres.
Cosine similarity in embedding space:
similarity("cat", "lion") ≈ 0.89 ← very similar
similarity("cat", "moon") ≈ 0.12 ← not similar
similarity("king", "queen") ≈ 0.91 ← very similar
Une précaution concernant l’exemple célèbre où roi moins homme plus femme égale reine : cette arithmétique provient de Word2Vec en 2013 et non des embeddings des transformateurs. Les transformateurs apprennent leurs embeddings conjointement avec tous les autres paramètres, ce qui rend l’arithmétique vectorielle classique moins fiable. Ce qui reste valable, c’est le principe selon lequel les mots ayant des significations similaires occupent des régions voisines dans cet espace.
Une largeur partout
Une dimension fixe, d_model, apparaît partout dans un transformateur : dans les embeddings, les sorties de l’attention, ainsi que dans les entrées et sorties des couches feed-forward. C’est intentionnel. Chaque composant lit dans et écrit vers un flux de vecteurs à largeur fixe, appelé le flux résiduel, qui circule à travers chaque couche. Comme tous les composants travaillent sur un vecteur de même taille et y ajoutent leurs résultats, les éléments s’assemblent proprement. C’est également la raison pour laquelle l’information de position peut être simplement ajoutée à un embedding de token : les deux ont la même forme, et leur somme est directement intégrée au flux.
L’entrée du premier bloc est donc l’incorporation des tokens ainsi qu’un vecteur de position. Comme ces deux éléments appartiennent au même espace, leur addition ne nécessite pas de paramètres supplémentaires, et les informations de position sont intégrées dans les mêmes vecteurs qui transmettent le sens. Les modèles de type BERT qui analysent deux phrases ensemble, comme dans les systèmes de réponse à des questions avec une question et un texte, ajoutent une incorporation de segment indiquant à quelle phrase appartient chaque token : 0 pour la première et 1 pour la seconde. Les modèles de type GPT l’omettent.
Attention : apprendre où regarder
Aux alentours de 2014 et 2015, les chercheurs travaillant sur la traduction automatique ont remarqué une faille même dans les systèmes LSTM. Le modèle compressait tout ce qu’il savait sur la phrase d’entrée en un vecteur de taille fixe avant de commencer à générer la sortie, ce qui constituait un autre goulot d’étranglement. La question évidente était de savoir si le modèle pouvait jeter un coup d’œil à l’ensemble de l’entrée à chaque étape de génération. La réponse à cette question a donné naissance au mécanisme d’attention, qui a changé la manière dont les séquences sont modélisées.
Deux situations courantes rendent cette idée intuitive.
Lors d’une fête bruyante où se déroulent dix conversations en même temps, le cerveau ne accorde pas la même importance à chaque son lorsqu’il suit un ami. Il amplifie la voix et le son provenant de cet ami tout en atténuant les autres, sans pour autant les éteindre complètement. Ce réglage de priorité est continu, et non basé sur un interrupteur allumé/éteint.
Lorsqu’on lui demande de trouver l’enseignant à partir d’une photo de classe, une personne ne scanne pas chaque pixel de manière égale. La recherche se dirige directement vers des caractéristiques indiquant un adulte, comme la taille par rapport aux autres et les proportions du visage. Ce que l’on cherche guide le regard.
L’attention computationnelle transforme ces intuitions en quatre étapes : disposer de quelque chose à chercher, c’est-à-dire la requête ; avoir un ensemble de candidats susceptibles d’être pertinents ; attribuer à chaque candidat une note de pertinence continue ; et combiner ces informations en fonction de ces notes.
Une idée fausse à éclaircir dès le début : l’attention ne signifie pas que le modèle se concentre sur une seule chose et ignore tout le reste. Le résultat est une moyenne pondérée à laquelle chaque élément contribue, certains bien plus que d’autres. Il s’agit d’une considération graduelle et non d’un focus binaire.
La forme originale, ajoutée ultérieurement
Dans sa première forme, l’attention était un complément pour les modèles RNN et LSTM. À chaque étape de décodage, le modèle procédait comme suit :
- examinait tous les états cachés de l’encodeur ;
- calculait un score de pertinence entre l’état actuel du décodeur et chaque état de l’encodeur ;
- transformait ces scores en poids à l’aide de softmax ;
- utilisait la somme pondérée des états de l’encodeur comme contexte d’attention.
Softmax mérite une brève explication. Il convertit un vecteur de nombres réels arbitraires en une distribution de probabilités. Chaque score devient e élevé à ce score, divisé par la somme de e élevé à chaque score. Tous les résultats sont positifs et leur somme est égale à 1 ; comme l’exponentielle exagère l’écart entre les scores élevés et ceux faibles, l’élément ayant le score le plus élevé reçoit la part de poids la plus importante.
C’était une amélioration majeure, car le modèle pouvait désormais accéder à n’importe quelle partie de l’entrée à chaque étape. Ensuite, les auteurs de « Attention Is All You Need » ont posé une question encore plus audacieuse : que se passerait-il si le mécanisme récurrent était supprimé et que l’attention n’était plus un élément supplémentaire, mais le modèle tout entier ?
L’auto-attention et le trio requête, clé, valeur
L’idée centrale de l’étude de 2017 est l’auto-attention. Plutôt que d’attirer l’attention d’une séquence vers une autre, chaque token d’une même séquence attire l’attention de tous les autres tokens de cette même séquence. C’est ainsi qu’un transformateur construit le contexte, et pour le comprendre, il faut trois vecteurs présents dans chaque calcul d’attention : la requête, la clé et la valeur.
Un moteur de recherche vidéo
En saisissant « comment faire du pain au levain » sur un site de vidéos, le texte n’est pas comparé à chaque frame de chaque vidéo. Chaque vidéo possède des étiquettes de métadonnées qui agissent comme des clés : titre, mots-clés, description. Le site compare la requête à ces étiquettes pour obtenir des scores de pertinence, et les vidéos ayant les meilleurs scores sont affichées afin que leur contenu réel puisse être récupéré.
Il existe cependant un élément important à prendre en compte. Le résultat n’est pas une seule vidéo. Il s’agit d’un mélange pondéré de toutes les vidéos en même temps, chacune étant diffusée à un volume proportionnel à son degré de pertinence. La vidéo la plus pertinente domine, avec des contributions plus faibles des autres en arrière-plan. La correspondance est la suivante :
| YouTube Concept | Attention Concept | Question it Answers |
|----------------|------------------|---------------------|
| Search query | **Query (Q)** | "What am I looking for?" |
| Video metadata/tags | **Key (K)** | "What do I contain?" |
| Actual video content | **Value (V)** | "What should I contribute?" |
Pourquoi trois vecteurs distincts ?
Pourquoi ne pas comparer directement les embeddings ? Prenons la phrase « Le chat était assis sur le tapis parce qu’il était fatigué ». Pour déterminer à quoi fait référence « il », le mot doit prêter attention au « chat ». Cependant, dans l’espace d’embedding brut, un pronom et un nom ne sont pas particulièrement similaires. En les divisant en requêtes et en clés, le modèle peut apprendre que la requête d’un pronom doit correspondre aux clés des noms auxquels il peut se référer, même lorsque le pronom et le nom ne ressemblent en rien dans leurs embeddings de base. Les projections apprises créent un espace de pertinence distinct de l’espace de similarité des embeddings bruts. La pertinence et la similarité sont deux concepts différents, et la conception QKV permet à un modèle d’encoder les deux.
L’attention par produit scalaire en quatre étapes
La première étape est la projection. L’embedding de chaque token est multiplié par trois matrices apprises, W_Q, W_K et W_V, ce qui produit une requête, une clé et une valeur pour ce token.
La deuxième étape mesure la compatibilité. La question est de savoir dans quelle mesure le token a correspond au token b, et la réponse est le produit scalaire de la requête de a avec la clé de b. Une valeur élevée signifie que le token a doit prêter une grande attention au token b. Les produits scalaires augmentent avec la taille du vecteur et avec la dimension de la clé d_k, et non seulement avec sa direction ; c’est pourquoi l’étape suivante les rééchelle.
La troisième étape effectue une rééchelle et une normalisation. Lorsque d_k est grand, les produits scalaires bruts deviennent importants et poussent la fonction softmax vers des régions où les gradients sont très faibles. En divisant par la racine carrée de d_k avant l’application de softmax, on évite cela, ce qui donne à cette méthode son nom : attention par produit scalaire rééchelonné. Le résultat est un ensemble de poids alpha_ab.
La quatrième étape consiste en l’agrégation. La sortie pour le token a est la somme, pour chaque token b, de alpha_ab multiplié par le vecteur de valeurs de b.
Tous les tokens peuvent être traités ensemble en tant que matrices, en une seule ligne concise : Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. Le diagramme l’illustre pour l’expression de trois mots « the cat sat » :
╔══════════════════════════════════════════════════════════════════════════════╗
║ SCALED DOT-PRODUCT ATTENTION ── "the cat sat" ║
╚══════════════════════════════════════════════════════════════════════════════╝
STEP 1: Input embeddings - ALL tokens are stacked into one matrix X
┌─────────────────────────────────────────┐
│ "the"→x₁ "cat"→x₂ "sat"→x₃ │ X ∈ ℝⁿˣᵈ
└──────────────────┬──────────────────────┘
│ the SAME X feeds all three projections
STEP 2: Three separate linear projections (each applied to every token)
┌─────────────┴─────────────┐
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ W_Q │ │ W_K │ │ W_V │ ← learned weight matrices
└────┬────┘ └────┬────┘ └────┬────┘
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Q rows │ │ K rows │ │ V rows │
│ q₁ │ │ k₁ │ │ v₁ │
│ q₂ │ │ k₂ │ │ v₂ │
│ q₃ │ │ k₃ │ │ v₃ │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
STEP 3: score = QKᵀ, scale by 1/√dₖ, then softmax row-wise
│ │ │
└──────┬──────┘ │
▼ │
┌─────────────────────┐ │
│ softmax(QKᵀ / √dₖ) │ │
│ the cat sat │ │
│ the[.72 .20 .08] │ │ each row
│ cat[.12 .71 .17] │ │ sums to 1.0
│ sat[.09 .28 .63] │ │
└──────────┬──────────┘ │
│ │
STEP 4: multiply weights by Values V (weighted sum)
└──────────┬─────────┘
▼
┌─────────────────┐
│ output for "cat"│ 0.12·v₁ + 0.71·v₂ + 0.17·v₃
└────────┬────────┘ ← rich context-aware vector
│
OUTPUT: contextualized token representations
┌──────────┐ ┌──────────┐ ┌──────────┐
│"the" │ │"cat" │ │"sat" │
│knows it │ │knows it │ │knows │
│precedes │ │sat, and │ │who was │
│"cat" │ │where │ │sitting │
└──────────┘ └──────────┘ └──────────┘
Un cas concret : le vocabulaire
Prenons l’expression « Elle est allée à la banque pour déposer de l’argent ». Alors que le transformateur encode le mot « banque », l’auto-attention permet à ce mot d’examiner en même temps tous les autres mots. Un poids élevé est attribué à « déposer » et « argent », ce qui introduit une connotation financière dans la représentation de « banque ». Le contexte permet de résoudre l’ambiguïté.
╔══════════════════════════════════════════════════════════════════════════════╗
║ SELF-ATTENTION RESOLVES AMBIGUITY: What does "bank" mean? ║
╚══════════════════════════════════════════════════════════════════════════════╝
Sentence: "I went to the bank to deposit money"
t₁ t₂ t₃ t₄ t₅ t₆ t₇ t₈
ATTENTION WEIGHTS for token "bank" (t₅) attending to all other tokens:
Token │ Weight │ Visualization
──────────┼────────┼───────────────────────────────────────────
"I" │ 0.03 │ ░
"went" │ 0.04 │ ░
"to" │ 0.02 │
"the" │ 0.03 │ ░
"bank" │ 0.08 │ ░░
"to" │ 0.05 │ ░
"deposit" │ 0.38 │ ████████████████████████░░░░░░░░ ← strong!
"money" │ 0.37 │ ████████████████████████░░░░░░░ ← strong!
FULL ATTENTION HEATMAP (rows = query token, columns = key token):
Higher weight → more ░/▒/▓/█
Q\K │ I went to the bank to deposit money
──────────┼──────────────────────────────────────────────
I │ ▓ ░ ░ ░ ░ ░ ░ ░
went │ ░ ▓ ░ ░ ░ ░ ░ ░
bank │ ░ ░ ░ ░ ▒ ░ █ █ ← "bank"→"deposit","money"
deposit │ ░ ░ ░ ░ █ ░ ▓ ▒ ← "deposit"→"bank"
money │ ░ ░ ░ ░ █ ░ ▒ ▓ ← "money"→"bank"
BEFORE attention: "bank" = ambiguous (river bank? financial bank?)
AFTER attention: "bank" ≈ 0.38·v(deposit) + 0.37·v(money) + ...
→ "bank" representation is now strongly financial ✓
The model learned this WITHOUT any explicit disambiguation rules.
Les poids présentés dans cette illustration ont été inventés à des fins de clarté et ne proviennent pas d’un modèle réel. Les motifs réels ont tendance à être plus désordonnés, et la recherche sur la manière dont les poids d’attention correspondent à ce que le modèle « pense » est encore en cours. Les avantages pratiques sont distincts de l’illustration : l’autodépendance attentionnelle pour tous les tokens correspond à une multiplication matricielle, c’est-à-dire une seule opération GPU. Ce qui coûte à un RNN n étapes séquentielles coûte à un transformateur une seule opération parallèle, et c’est pourquoi les transformateurs sont plus efficaces en termes de scalabilité.
Plusieurs têtes, plusieurs perspectives
Une seule unité de traitement calcule un type de pertinence à la fois, alors que se passe-t-il lorsque plusieurs types de relations sont importants en même temps ? Prenons l’exemple : « Le musicien qui a joué au festival a gagné le prix. » Comprendre cette phrase nécessite de suivre plusieurs dépendances en parallèle : le verbe « a gagné » avec le sujet et l’objet « musicien », le mot « musicien » avec l’action « a joué » via la proposition relative, « a joué » avec le lieu « festival », et enfin « le prix » avec le verbe et l’objet « a gagné ».
Une seule tête devrait regrouper tout cela dans un seul ensemble de poids. L’attention multi-têtes, en revanche, exécute la fonction d’attention h fois en parallèle, chaque fois avec ses propres projections apprises pour les requêtes, les clés et les valeurs. Les h sorties sont concaténées puis passées à travers une autre matrice apprise, W_O, qui les ramène à la dimension du modèle. Chaque tête travaille dans un sous-espace plus petit, avec d_k égal à d_model divisé par h, de sorte que le coût total pour toutes les têtes est à peu près équivalent à celui d’une seule tête de largeur complète.
Imaginez un manuscrit envoyé à un comité de rédaction. Un correcteur grammatical vérifie la syntaxe, un correcteur de style suit le flux narratif, un vérificateur de faits cherche la cohérence sémantique et un correcteur structurel observe l’organisation à long terme. Ils lisent tous en même temps et de manière indépendante, et leurs notes sont fusionnées en une seule critique. L’attention multi-têtes fonctionne de la même manière.
╔══════════════════════════════════════════════════════════════════════════════╗
║ MULTI-HEAD ATTENTION (3 heads shown) ║
╚══════════════════════════════════════════════════════════════════════════════╝
Input Embedding x ∈ ℝᵈ_model
┌────────────────────────────┐
│ [ x₁ x₂ x₃ ... xₙ ] │
└──────────┬─────────────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
▼ ▼ ▼
╔══════════════╗ ╔══════════════╗ ╔══════════════╗
║ HEAD 1 ║ ║ HEAD 2 ║ ║ HEAD 3 ║
║ "Syntax" ║ ║ "Semantics" ║ ║ "Position" ║
║ ║ ║ ║ ║ ║
║ W_Q¹ W_K¹ ║ ║ W_Q² W_K² ║ ║ W_Q³ W_K³ ║
║ W_V¹ ║ ║ W_V² ║ ║ W_V³ ║
║ ║ ║ ║ ║ ║
║ ┌──────────┐ ║ ║ ┌──────────┐ ║ ║ ┌──────────┐ ║
║ │ Scaled │ ║ ║ │ Scaled │ ║ ║ │ Scaled │ ║
║ │ Dot- │ ║ ║ │ Dot- │ ║ ║ │ Dot- │ ║
║ │ Product │ ║ ║ │ Product │ ║ ║ │ Product │ ║
║ │Attention │ ║ ║ │Attention │ ║ ║ │Attention │ ║
║ └────┬─────┘ ║ ║ └────┬─────┘ ║ ║ └────┬─────┘ ║
║ │ ║ ║ │ ║ ║ │ ║
║ learns: ║ ║ learns: ║ ║ learns: ║
║ subject-verb ║ ║ word meaning ║ ║ nearby-word ║
║ agreement ║ ║ similarity ║ ║ relationships║
╚══════╤═══════╝ ╚══════╤═══════╝ ╚══════╤═══════╝
│ head₁ ∈ ℝⁿˣ⁽ᵈ/ʰ⁾ │ head₂ │ head₃
└───────────────────┼───────────────────┘
▼
┌──────────────────────────────┐
│ CONCATENATE all heads │
│ [head₁ ║ head₂ ║ head₃] │ ∈ ℝⁿˣᵈ_model
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Final linear projection W_O │ blends info from all heads
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Multi-Head Attention Output │ ∈ ℝⁿˣᵈ_model (same shape as input)
└──────────────────────────────┘
Que font finalement les têtes
Les analyses des modèles entraînés ont révélé l’existence de têtes spécialisées. Certaines se chargent de la syntaxe, comme l’accord sujet-verbe ou les modificateurs attachés aux noms. D’autres agissent sur de longues distances, reliant les pronoms à leurs antécédents. D’autres encore sont locales et s’intéressent aux mots adjacents ainsi qu’aux motifs bigrammatiques. Certaines enregistrent la distance relative entre les tokens, tandis que d’autres identifient les rôles thématiques, c’est-à-dire qui a fait quoi à qui. Personne ne programme cela ; l’entraînement récompense les prédictions précises, et le réseau découvre que diviser le travail entre des têtes spécialisées est efficace.
Une limite à ce raisonnement : ces catégories proviennent principalement d’études sur l’interprétabilité de modèles plus petits. Dans les grands modèles, de nombreuses parties ne peuvent pas être analysées clairement, et des expériences montrent que de tels modèles survivent souvent à la suppression de nombreuses parties sans subir de pertes significatives. L’architecture permet la spécialisation, mais ne garantit pas des divisions claires et lisibles par les humains.
Attribuer une adresse aux mots
L’auto-attention met en relation chaque paire de tokens, mais elle traite la séquence comme un ensemble sans ordre. Le score entre un token a et un token b dépend uniquement de leur contenu, et non de l’ordre dans lequel ils apparaissent ou de la distance qui les sépare. Le langage est fortement dépendant de l’ordre. « Le chien mord l’homme » et « L’homme mord le chien » contiennent les mêmes mots mais ont des sens opposés, et « pas heureux » signifie quelque chose de très différent de « heureux pas ». Comme un transformateur traite toutes les positions en parallèle, rien en lui ne code par défaut l’ordre, il faut donc l’injecter explicitement. C’est là la fonction de l’encodage positionnel.
Imaginez l’ajout de métadonnées à chaque bâtiment d’une ville. Chacun a besoin d’une adresse qui indique précisément son emplacement, exprime sa position relative (le bâtiment 402 se trouve près du 404) et fonctionne sans qu’il soit nécessaire de connaître à l’avance le plan complet de la ville. Les coordonnées GPS accomplissent cela efficacement. L’encodage positionnel est la version linguistique : une coordonnée mathématique ajoutée à la représentation de chaque mot.
Ondes sinusoïdales et cosinusoidales
Le transformateur original utilisait des fonctions sinusoïdales, avec une fréquence par paire de dimensions d’encodage. Pour la position pos et l’indice de dimension k, les sinus et cosinus de pos divisés par une puissance de 10000, puis multipliés par k, remplissent le vecteur. Les ondes lentes à faible fréquence indiquent une position grossière, tandis que les ondes rapides à haute fréquence indiquent une position fine ; ensemble, elles confèrent à chaque position un empreinte unique.
╔══════════════════════════════════════════════════════════════════════════╗
║ SINUSOIDAL POSITIONAL ENCODING ║
╚══════════════════════════════════════════════════════════════════════════╝
GRID: exact values for a tiny d_model=8 - positions 0-4, dims 0-7
(frequency denominators are 1, 10, 100, 1000 for dim-pairs 0,1,2,3)
dim→ d=0 d=1 d=2 d=3 d=4 d=5 d=6 d=7
sin cos sin cos sin cos sin cos
pos↓ ──────────────────────────────────────────────────────
pos=0 │ 0.000 1.000 0.000 1.000 0.000 1.000 0.000 1.000 │
pos=1 │ 0.841 0.540 0.100 0.995 0.010 1.000 0.001 1.000 │
pos=2 │ 0.909 -0.416 0.199 0.980 0.020 1.000 0.002 1.000 │
pos=3 │ 0.141 -0.990 0.296 0.955 0.030 1.000 0.003 1.000 │
pos=4 │ -0.757 -0.654 0.389 0.921 0.040 0.999 0.004 1.000 │
↑ fast-changing ↑ medium-changing ↑ very slow
(high frequency) (mid frequency) (low freq)
unique per position gradual shift global structure
WAVE PATTERNS (each row = one dimension across positions):
dim 0 (sin): █ ▇ ▄ ▁ ▂ ▅ ▇ █ ▇ ▄ ▁ ← fast oscillation
dim 2 (sin): █ █ ▇ ▇ ▆ ▅ ▄ ▃ ▂ ▁ ▁ ← medium oscillation
dim 4 (sin): █ █ █ █ █ █ ▇ ▇ ▇ ▇ ▆ ← slow oscillation
dim 6 (sin): █ █ █ █ █ █ █ █ █ █ █ ← very slow oscillation
HOW IT'S USED: Added to the token embedding elementwise
┌─────────────────┐ ┌─────────────────┐ ┌──────────────────┐
│ Token Embedding│ │ Positional Enc. │ │ Final Input x_t │
│ "cat" │ │ position = 2 │ │ │
│ [0.2, 0.8, │ │ [0.9,-0.4, │ │ [1.1, 0.4, │
│ 0.1, 0.5, │ + │ 0.2, 1.0, │ = │ 0.3, 1.5, │
│ 0.9, 0.3] │ │ 0.0, 1.0] │ │ 0.9, 1.3] │
│ (meaning) │ │ (where in seq) │ │ (meaning+position)│
└─────────────────┘ └─────────────────┘ └──────────────────┘
WHY SINUSOIDS?
✓ Each position gets a unique encoding across all dimensions
✓ Distance between nearby positions is consistent and learnable
✓ Can represent any position mathematically (unlike learned embeddings)
✓ Model can attend to relative positions via linear combinations
Les dimensions inférieures oscillent rapidement et capturent des détails de position précis, tandis que les dimensions supérieures changent lentement et capturent l’ordre global. Le vecteur est simplement ajouté à l’incorporation du token.
Ondes fixes, tables apprises et rotation
Le schéma sinusoïdal possède une propriété mathématique utile : l’encodage en position pos+k est une fonction linéaire de l’encodage en position pos. Les décalages relatifs sont donc représentés de manière cohérente, ce qui facilite l’apprentissage des relations de position.
Les embeddings de position appris, qui consistent en un tableau séparé contenant une entrée par position comme le fait BERT, sont plus simples mais ne peuvent pas extrapoler au-delà des positions vues pendant l’entraînement, tandis que les sinusoides peuvent en principe représenter n’importe quelle position. Néanmoins, les sinusoides ne résolvent pas pleinement le problème de la généralisation sur de longs contextes. Les modèles ont encore du mal avec des séquences bien plus longues que leurs données d’entraînement, car les schémas d’attention eux-mêmes doivent également généraliser sur des distances inconnues.
Des modèles tels que Llama utilisent les embeddings de position rotatifs, ou RoPE. Avant de calculer les produits scalaires, les requêtes et les clés sont rotées d’un angle proportionnel à leur position. Dans le produit d’une requête située en une position donnée et d’une clé située ailleurs, la rotation relative encode directement l’offset. En faisant de la position relative une entrée explicite dans le score d’attention, plutôt que quelque chose d’implicite appris à travers les matrices de projection, cela facilite le traitement de contextes longs.
L’architecture complète
Les éléments peuvent maintenant être assemblés. Le diagramme montre la forme moderne Pre-LayerNorm de toute la structure :
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║ THE COMPLETE TRANSFORMER ARCHITECTURE (Pre-LayerNorm, modern) ║
╠═══════════════════════════════════════════╦═══════════════════════════════════════════╣
║ ENCODER (×N layers) ║ DECODER (×N layers) ║
╠═══════════════════════════════════════════╬═══════════════════════════════════════════╣
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ Linear → Softmax → P(next token) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ ⊕ Add (residual) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ FFN( LayerNorm(x) ) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ Encoder output → K, V (to decoder) ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ ⊕ Add (residual) │ ║
║ ┌───────────────────────────────────────┐ ║ └───────────────────────────────────────┘ ║
║ │ ⊕ Add (residual) │ ║ ▲ ║
║ └───────────────────────────────────────┘ ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ Cross-Attention │ ║
║ ┌───────────────────────────────────────┐ ║ │ Q ← decoder │ ║
║ │ FFN( LayerNorm(x) ) │ ║ │ K, V ← encoder output │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ ⊕ Add (residual) │ ║ │ ⊕ Add (residual) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Multi-Head Self-Attention │ ║ │ Masked Multi-Head Self-Attention │ ║
║ │ ( on LayerNorm(x), bidirectional ) │ ║ │ ( on LayerNorm(x), causal ) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Input Embedding + Positional Enc. │ ║ │ Output Embedding + Positional Enc. │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Source: "The cat sat on the mat" │ ║ │ Target (shifted): <BOS> "Le" "chat"… │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
╠═══════════════════════════════════════════╩═══════════════════════════════════════════╣
║ Data flows UPWARD (▲). Each sub-layer is a residual branch over a ║
║ LayerNorm-ed input: h = x + SubLayer( LayerNorm(x) ) ║
║ The encoder's output (K, V) flows into the decoder's Cross-Attention. ║
╚═══════════════════════════════════════════════════════════════════════════════════════╝
Un transformateur se compose de deux parties principales : un encodeur et un décodeur. Dans l’article original, chacun d’eux disposait de 6 couches, avec 8 têtes d’attention et un d_model de 512.
L’encodeur : la compréhension dans le contexte
L’encodeur lit la séquence d’entrée et génère une représentation contextualisée de chaque token, en prenant en compte non pas ce qu’un mot signifie isolément, mais ce qu’il signifie dans cette phrase particulière. Il utilise l’auto-attention bidirectionnelle, ce qui permet à chaque token de prendre en compte tous les autres tokens des deux côtés. C’est ainsi que l’ambiguïté mentionnée précédemment avec le mot « bank » est résolue : le modèle voit en même temps les mots « deposit » et « money ».
Six couches d’encodage s’exécutent séquentiellement, chacune affinant la représentation. Les couches initiales se concentrent sur des aspects syntaxiques tels que l’ordre des mots et la catégorie grammaticale. Les couches intermédiaires traitent des structures grammaticales plus complexes. Les couches ultérieures capturent des significations de haut niveau telles que les types d’entités, la structure des événements et la pragmatique. Cette hiérarchie explique pourquoi le transfert de connaissances fonctionne si bien : le réglage fin modifie principalement les couches ultérieures, tandis que les schémas linguistiques généraux des couches initiales restent utiles pour différentes tâches.
Le décodeur : génération avec mémoire
Le décodeur émet des tokens de sortie un par un, de manière autoregressive. Chaque nouveau token dépend de tout ce qui a été généré jusqu’à présent ainsi que de l’ensemble de l’entrée encodée. Il comporte trois sous-couches.
Le premier est l’attention auto-masquée, également appelée attention causale. Le décodeur ne peut prendre en compte que les tokens qu’il a déjà générés, ce qui est imposé par un masque causal. Les scores situés au-dessus de la diagonale sont mis à moins d’infini avant l’application de softmax, ce qui rend les tokens futurs invisibles. L’entraînement correspond ainsi à l’inference, car le modèle doit prédire chaque token uniquement à partir du contexte passé.
╔══════════════════════════════════════════════════════════════════════════╗
║ DECODER SELF-ATTENTION: Causal (Autoregressive) Masking ║
║ "Each token can only attend to itself and tokens before it" ║
╚══════════════════════════════════════════════════════════════════════════╝
Tokens: [The] [cat] [sat] [on] [mat]
t₁ t₂ t₃ t₄ t₅
ATTENTION SCORE MATRIX (row = query, col = key)
KEY → t₁ t₂ t₃ t₄ t₅
QUERY ↓ "The" "cat" "sat" "on" "mat"
──────────────────────────────────────
t₁ "The" │ ✓ ✗ ✗ ✗ ✗
t₂ "cat" │ ✓ ✓ ✗ ✗ ✗
t₃ "sat" │ ✓ ✓ ✓ ✗ ✗
t₄ "on" │ ✓ ✓ ✓ ✓ ✗
t₅ "mat" │ ✓ ✓ ✓ ✓ ✓
✓ = ALLOWED (score kept, participates in softmax)
✗ = MASKED (score → −∞, becomes 0 after softmax)
When generating t₃ "sat":
Raw scores: [ 2.1 3.4 1.8 -∞ -∞ ]
After softmax: [ 0.18 0.68 0.14 0 0 ]
↑
future tokens are invisible
WHY IS MASKING NECESSARY?
┌──────────────────────────────────────────────────────────┐
│ TRAINING: We feed the whole target sequence at once │
│ (teacher-forcing). Without masking, t₃ could "cheat" │
│ by looking at t₄ and t₅ - the answers it should │
│ be predicting. │
│ │
│ INFERENCE: We generate one token at a time anyway, │
│ so future tokens literally don't exist yet. Masking │
│ makes training match inference behavior exactly. │
└──────────────────────────────────────────────────────────┘
Le deuxième élément est l’attention croisée, le lien entre l’encodeur et le décodeur. Les requêtes proviennent du décodeur, représentant l’état actuel de la génération, tandis que les clés et les valeurs proviennent de l’encodeur, représentant ce qui a été dit en entrée. La traduction fonctionne de cette manière : lorsque le décodeur produit le mot français « chat », il interroge la représentation de toute la phrase anglaise par l’encodeur, et l’attention croisée accorde un poids important à « cat ».
Le troisième élément est le réseau feed-forward, dont le rôle est identique à celui du réseau de l’encodeur et qui sera abordé plus loin.
Trois familles construites à partir des mêmes composants
La combinaison encodeur-décodeur n’est qu’une façon d’utiliser ces composants, et différentes tâches exigent des arrangements différents :
| Model | Architecture | Training Objective | Best For |
|-------|-------------|-------------------|----------|
| **BERT** | Encoder-only | Masked Language Modeling | Understanding: classification, NER, QA |
| **GPT** | Decoder-only | Next token prediction | Generation: writing, coding, conversation |
| **T5** | Encoder-Decoder | Text-to-text seq-to-seq | Transformation: translation, summarization |
╔══════════════════════════════════════════════════════════════════════════════════════╗
║ BERT vs GPT vs T5: Architecture Families ║
╠══════════════════╦═══════════════════════════╦═════════════════════════════════════╣
║ BERT ║ GPT ║ T5 ║
║ Encoder-Only ║ Decoder-Only ║ Encoder + Decoder ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ ATTENTION: ║ ATTENTION: ║ ATTENTION: ║
║ t₁ ● ● ● ● ║ t₁ ● ║ Encoder: ● ● ● ● (bidir) ║
║ t₂ ● ● ● ● ║ t₂ ● ● ║ ● ● ● ● ║
║ t₃ ● ● ● ● ║ t₃ ● ● ● ║ Decoder: causal + ║
║ t₄ ● ● ● ● ║ t₄ ● ● ● ● ║ cross-attn to encoder ║
║ (bidirectional) ║ (causal/left-only) ║ ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ BEST FOR: ║ BEST FOR: ║ BEST FOR: ║
║ ✓ Classification ║ ✓ Text generation ║ ✓ Translation ║
║ ✓ NER / tagging ║ ✓ Completion ║ ✓ Summarization ║
║ ✓ Sentence embeds ║ ✓ Chat / dialogue ║ ✓ Question answering ║
║ ✓ Reading comp. ║ ✓ Code generation ║ ✓ Any seq-to-seq task ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ EXAMPLES: ║ EXAMPLES: ║ EXAMPLES: ║
║ BERT, RoBERTa ║ GPT-4o, Claude 4, ║ T5, BART, ║
║ DeBERTa ║ Llama 4, Gemini 2.5 ║ mT5, FLAN-T5 ║
╚══════════════════╩═══════════════════════════╩═════════════════════════════════════╝
BERT lit dans les deux directions et convient aux tâches de compréhension. GPT génère de gauche à droite sous un masquage causal. T5 conserve l’architecture complète pour des transformations séquence à séquence structurées. Le choix parmi eux concerne l’adaptation de l’architecture à la tâche, et non le fait de savoir lequel est le meilleur. En bref, l’encodeur crée des représentations contextuelles bidirectionnelles, le décodeur génère de manière autoregressive avec masquage causal et attention croisée, et différents sous-ensembles de l’architecture sont ajustés pour la compréhension, la génération et la transformation.
Les éléments complémentaires
L’attention et la couche feed-forward reçoivent l’essentiel de l’attention, mais trois autres éléments empêchent les transformateurs profonds de s’effondrer pendant l’entraînement : les réseaux feed-forward eux-mêmes, la normalisation par couche et les connexions résiduelles.
Réseaux feed-forward : temps de traitement par token
Après chaque couche d’attention dans chaque bloc se trouve un réseau feed-forward par position. Le vecteur de chaque token passe par le même réseau MLP à deux couches, appliqué séparément à chaque position : on le multiplie par W1, on ajoute un biais, on applique une non-linéarité GeLU, puis on le multiplie par W2 et on ajoute un autre biais. W1 transforme les données de d_model en quatre fois cette valeur, tandis que W2 inverse ce processus. Dans les tailles initiales, cela correspond à une expansion de 512 à 2048 puis à une contraction à 512, ce qui permet au réseau de stocker et de transformer des informations que l’attention seule ne peut pas capturer.
Le terme clé est « par position », car cette couche traite chaque token de manière indépendante. L’attention constitue le mécanisme de communication, permettant aux tokens de s’entretenir, tandis que le réseau feed-forward est le mécanisme de calcul, où chaque token traite les informations qu’il a collectées.
Geva et ses collaborateurs (2021) ont découvert que ces couches se comportent un peu comme des mémoires clé-valeur, et qu’il est possible d’identifier des neurones spécifiques qui s’activent pour certaines notions sémantiques. Lorsqu’un modèle de langage « sait » que Paris est la capitale de la France, cette association réside principalement dans les poids feed-forward. Cela explique deux choses : le fine-tuning peut mettre à jour les connaissances factuelles car il modifie ces poids ; de plus, la génération augmentée par le rappel fonctionne parce qu’elle place l’information dans la fenêtre de contexte, où l’attention peut y accéder directement.
Connexions résiduelles
Les gradients qui se propagent en sens inverse à travers un réseau profond s’amenuisent au fil de plusieurs couches. Une connexion résiduelle, également appelée connexion sautée, résout ce problème de manière élégante : la sortie d’une sous-couche correspond au résultat obtenu par cette sous-couche plus son propre entrée. La couche n’a alors qu’à apprendre la différence, c’est-à-dire le résidu, et non toute la fonction de mappage. Cela crée une voie directe le long de laquelle les gradients peuvent revenir en arrière sans passer par aucune couche, ce qui explique pourquoi les transformateurs modernes peuvent disposer de 96 couches ou plus sans que l’entraînement ne échoue.
Normalisation des couches : maintenir les échelles sous contrôle
La normalisation par couche standardise le vecteur d’activation de chaque token en ayant une moyenne nulle et une variance unitaire, puis applique une échelle apprise gamma ainsi qu’un décalage beta. Les statistiques proviennent des caractéristiques d_model d’un token : la moyenne correspond à la simple moyenne de ses valeurs, et la variance est la moyenne des distances carrées par rapport à cette moyenne. Une petite constante epsilon, généralement égale à 10 au puissance moins 5, est insérée dans la racine carrée afin d’éviter toute division par zéro. Contrairement à la normalisation par lot, le calcul s’effectue pour chaque token indépendamment du lot, ce qui convient aux séquences de longueur variable.
Le modèle de bloc moderne
La version originale du papier appliquait LayerNorm après l’addition résiduelle, ce qu’on appelle Post-LN. Presque tous les modèles modernes, du GPT-2 et GPT-3 au Llama, ainsi que pratiquement tous les modèles entraînés depuis environ 2020, utilisent Pre-LayerNorm et normalisent les données avant chaque sous-couche. Pre-LN permet un entraînement plus stable et n’exige pas de phase d’échauffement du taux d’apprentissage.
Chaque bloc ajoute ensuite une branche d’attention et une branche feed-forward autour des entrées normalisées. Le premier état intermédiaire correspond à l’entrée plus l’attention appliquée à cette entrée normalisée, tandis que le deuxième état correspond à cet état plus le réseau feed-forward appliqué à sa propre version normalisée. En examinant le code de n’importe quel transformateur moderne, on constate que LayerNorm est placé avant l’étape d’attention et avant l’étape feed-forward. En répétant ce bloc N fois, où N vaut 6, 12, 24, 96 ou plus selon la taille du modèle, on obtient le transformateur complet.
Le mécanisme d’attention est l’idée ingénieuse. Ces éléments complémentaires constituent l’aspect technique qui permet à cette idée ingénieuse de fonctionner. Les couches feed-forward effectuent des calculs par token afin de stocker des associations factuelles, les chemins résiduels fournissent un itinéraire aux gradients à travers la profondeur, et Pre-LN maintient les activations stables. Ensemble, ils rendent possible l’empilement de dizaines de blocs.
Le parcours d’une phrase
Une exécution de bout en bout se déroule comme suit : tokenisation, embedding, ajout d’une encodage de position, encodage, décodage d’un token à la fois, puis projection vers le vocabulaire. Le diagramme suivant montre le processus de traduction de « Hello world » :
╔══════════════════════════════════════════════════════════════════════════╗
║ END-TO-END DATA FLOW: "Hello world" → Translation ║
╚══════════════════════════════════════════════════════════════════════════╝
STAGE 1: Tokenization
┌─────────────────────────────────────────────────────────────────┐
│ Raw text: "Hello world" │
│ ↓ Tokenizer (BPE / WordPiece) │
│ Token IDs: [ 7592, 2088 ] ← integers into vocabulary │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 2: Embedding Lookup e_t = E[t] ∈ ℝ^512
┌─────────────────────────────────────────────────────────────────┐
│ 7592 → [0.21, -0.54, 0.88, ...] "Hello" │
│ 2088 → [0.67, 0.12,-0.34, ...] "world" │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 3: Add Positional Encoding x_t = e_t + PE(t)
┌─────────────────────────────────────────────────────────────────┐
│ embedding + PE = input vector carrying BOTH meaning AND order │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 4: Encoder Stack (× N layers)
┌─────────────────────────────────────────────────────────────────┐
│ ╔═══════════════════════════════════╗ │
│ ║ Each Encoder Layer: ║ × 6 │
│ ║ h₁ = x + Attn(LayerNorm(x)) ║ │
│ ║ h₂ = h₁ + FFN(LayerNorm(h₁)) ║ │
│ ╚═══════════════════════════════════╝ │
│ After 6 layers: rich contextual reps - "Hello" knows context │
└──────────────────────┬──────────────────────────────────────────┘
↓ (K, V flow into decoder cross-attention)
STAGE 5: Decoder Stack (generates tokens autoregressively)
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: <BOS> → Decoder → predict "Hola" │
│ Step 2: <BOS> "Hola" → Decoder → predict "mundo" │
│ Step 3: <BOS> "Hola mundo" → Decoder → predict <EOS> │
│ │
│ Each step: ① Masked self-attention on generated tokens │
│ ② Cross-attention: Q←decoder, K,V←encoder │
│ ③ LayerNorm → FFN → residual │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 6: Output Projection & Softmax
┌─────────────────────────────────────────────────────────────────┐
│ hidden state → W_vocab → logits over 50k vocab items │
│ → softmax → probability distribution │
│ → sample or argmax → next token │
└──────────────────────┬──────────────────────────────────────────┘
↓
"Hola mundo" ✓
Comment un article de traduction est devenu un modèle linguistique
Cela décrit l’architecture complète, mais comment un concept de traduction automatique a-t-il évolué pour donner naissance à des systèmes capables d’écrire des essais, du code et de résoudre des problèmes complexes ? La réponse courte est l’échelle.
Le calendrier ci-dessous couvre la période allant du transformateur de 2017 aux modèles les plus avancés actuels :
YEAR MODEL PARAMS KEY DEVELOPMENT
────────────────────────────────────────────────────────────────────────────────
2017 Transformer 65M "Attention Is All You Need" published
2018 GPT-1 117M First successful generative pre-training
2019 GPT-2 1.5B Improved fluency; staged release
2020 GPT-3 175B Few-shot in-context learning emerges
2022 ChatGPT 175B+ InstructGPT + RLHF = aligned conversational AI
2023 GPT-4 undisclosed Multimodal input + stronger reasoning
2024 GPT-4o undisclosed Natively multimodal, faster & cheaper (May)
2024 o1 undisclosed "Reasoning" model: thinks before answering (Sep)
2025 o3 / o4-mini undisclosed Stronger reasoning, tool use, long-horizon
2025 Claude 4 undisclosed Anthropic: Opus 4 / Sonnet 4 (May)
2025 Gemini 2.5 undisclosed Google: 1M-token context, multimodal
2025 Llama 4 undisclosed Meta: open weights, up to 10M-token context
2026 GPT-5 series undisclosed OpenAI flagship (GPT-5.4 / 5.5); 272K-1M ctx
2026 Gemini 3.x undisclosed Google: frontier reasoning; 1M context
2026 Claude 5 family undisclosed Anthropic: Opus 4.8, Sonnet 5, Fable 5
2026 Grok 4.x undisclosed xAI frontier line (Grok 4.5, Jul 2026)
(Every one is the same core transformer from 2017 — scaled and refined, not replaced)
L’architecture de base n’a pratiquement pas changé entre GPT-1 et les modèles de pointe d’aujourd’hui. Ce qui a changé, c’est ce suivant :
- La taille, c’est-à-dire davantage de paramètres, plus de données et plus de ressources informatiques.
- L’alignement, grâce à l’apprentissage par renforcement à partir des retours humains, ce qui rend les modèles utiles et sûrs.
- L’ajustement aux instructions, qui entraîne les modèles à suivre des directives plutôt qu’à simplement continuer un texte.
- L’entraînement au raisonnement, qui applique l’apprentissage par renforcement à grande échelle à des problèmes vérifiables. C’est l’élément fondamental derrière les modèles de raisonnement, tels que la série o d’OpenAI et les modes de réflexion approfondie désormais courants dans Claude, Gemini et d’autres, qui consacrent des ressources supplémentaires à la réflexion avant de répondre.
Capacités qui semblent se déclencher
Un phénomène inattendu s’est produit à mesure que les modèles grandissaient. Certaines capacités n’ont pas progressé de manière progressive et semblaient s’améliorer brusquement à des tailles particulières. Les calculs multi-étapes étaient presque absents avec moins de 10 milliards de paramètres, puis sont devenus fiables à partir de 100 milliards. Le raisonnement par chaîne de pensée était essentiellement absent à moins que le modèle ne soit suffisamment grand et qu’on ne l’y incite. La génération de code s’est considérablement améliorée au-delà de l’échelle GPT-3. Rien de tout cela n’a été programmé ; c’est apparu naturellement.
On débat de la véritable ampleur de ces sauts. Une analyse de 2023 très citée, menée par Schaeffer et ses collaborateurs sous le titre « Are Emergent Abilities of Large Language Models a Mirage? », a montré que certaines changements apparemment brusques proviennent en partie de la métrique utilisée. Évaluer une tâche en termes de réussite totale ou nulle, comme le fait la précision de correspondance exacte, peut transformer des progrès progressifs et stables en ce qui ressemble à un bond soudain, tandis qu’une métrique continue révèle les progrès réguliers qui se produisent en sous-main. Le point pratique reste valable, puisque les grands modèles accomplissent des choses que les petits ne peuvent pas, mais les valeurs seuil spécifiques doivent être considérées comme des illustrations approximatives et non comme des lois physiques strictes.
L’objectif d’entraînement de tout modèle de type GPT est la même tâche simple : prédire le token suivant. Le raisonnement, la génération de code, la compréhension multilingue et l’écriture créative ne sont jamais entraînés explicitement. Ils apparaissent à mesure que le modèle s’améliore dans la prédiction du token suivant, à condition qu’il dispose d’une ampleur suffisante : un corpus vaste, de haute qualité et diversifié, ainsi qu’un modèle suffisamment grand pour retenir les schémas nécessaires. C’est pourquoi les chercheurs qualifient cet objectif de trompeusement simple. L’objectif est simple, mais ce que le modèle doit apprendre pour y parvenir efficacement ne l’est pas.
La fenêtre de contexte en tant que mémoire de travail
La mémoire de travail, pour un modèle, correspond à la fenêtre de contexte : le nombre maximal de tokens qu’il peut traiter lors d’une seule passe forward. Sa capacité a connu une croissance spectaculaire. GPT-2, en 2019, pouvait gérer 1 024 tokens, tandis que GPT-3, en 2020, en gérait 2 048. GPT-4o, en 2024, a atteint 128 000 tokens. À la mi-2026, cette capacité avait encore augmenté : la série GPT-5 d’OpenAI propose 272 000 tokens en standard et environ un million via l’API ; Claude d’Anthropic et Gemini 3 de Google offrent également plus d’un million de tokens, tandis que Llama 4 Scout, dont les poids sont accessibles au public, affiche une capacité allant jusqu’à 10 millions de tokens, soit environ 15 000 pages. Ces chiffres continuent d’augmenter à chaque nouvelle génération.
Une fenêtre de contexte plus large est importante car elle permet d’analyser un fichier de code complet et non seulement des extraits, de maintenir la cohérence d’une conversation sur de nombreux échanges, de résumer des documents entiers, ainsi que de mener des raisonnements en plusieurs étapes en tenant compte de nombreux résultats intermédiaires.
Il y a un problème. Le calcul de la matrice d’attention complète, qui relie chaque token à tous les autres, nécessite un temps et de la mémoire proportionnels à O(n au carré) pendant l’entraînement. Doubler la longueur du contexte fait quadrupler ces besoins. Lors de l’inférence, le cache KV réduit les calculs par étape, mais la mémoire augmente toujours de manière linéaire avec la longueur du contexte. Ce goulot d’étranglement lié à une complexité quadratique est un domaine de recherche actif. L’attention sparse, l’attention à fenêtre glissante utilisée dans Mistral ainsi que d’autres architectures efficaces, Flash Attention (attention exacte à faible consommation mémoire) et les approximations linéaires cherchent toutes à réduire ces coûts.
Ce qui repose sur les fondations
L’attention, QKV, les multiples têtes, l’encodage positionnel et la structure encodeur-décodeur constituent les infrastructures de base, et la raison d’apprendre ces éléments réside dans tout ce qui est construit à partir d’eux.
L’IA générative consiste en une prédiction du token suivant répétée
Toute application générative repose, au fond, sur ce même cycle exécuté encore et encore :
Prompt: "Write a poem about autumn"
↓
Model predicts most likely next token: "The"
↓
Prompt + "The" → predicts: "leaves"
↓
Prompt + "The leaves" → predicts: "fall"
↓
... continues until <end-of-sequence> token predicted
Voir les choses de cette manière dissipe le mystère entourant plusieurs comportements :
- Hallucination. Le modèle prédit des tokens probables sans récupérer de faits dans une base de données. S’il existe un token plausible mais erroné, il peut être généré.
- Pourquoi le contexte est si important. Toute la fenêtre de contexte est prise en compte à chaque étape de génération, de sorte que tout ce qui figure dans la demande influence les poids d’attention calculés et donc le résultat obtenu.
Apprentissage in-context : l’attention comme mécanisme de récupération
L’une des capacités les plus remarquables des grands transformateurs est l’apprentissage in-context, qui permet d’adapter un modèle à une nouvelle tâche à partir d’exemples fournis dans la demande, sans aucune fine-tuning. Ce mécanisme correspond à ce qui a été expliqué précédemment. Les exemples de type few-shot occupent des positions dans la fenêtre d’attention. Lorsque le modèle traite l’instance de test, la requête associée à ce token est comparée par produit scalaire avec les clés de chaque token précédent, y compris les paires d’exemples. Comme ces exemples partagent un schéma structurel avec l’instance de test, leurs clés correspondent bien et leurs valeurs reçoivent des poids élevés. L’attention constitue littéralement le mécanisme de récupération, et c’est pourquoi la structure d’une demande, par son effet sur les schémas d’attention, modifie la sortie.
Agents : un transformateur en tant que moteur de raisonnement
Les agents d’IA sont des systèmes qui décomposent eux-mêmes les tâches, appellent des outils, s’adaptent en fonction des retours et poursuivent leurs objectifs à travers de nombreuses étapes. En 2023, ils n’étaient qu’une curiosité de recherche. Aujourd’hui, des produits tels que Claude Code, GitHub Copilot, Cursor et Devin sont utilisés quotidiennement par les développeurs. Chaque agent sérieux repose sur un modèle transformer à son cœur.
╔══════════════════════════════════════════════════════════════════════════════╗
║ THE CONTEXT WINDOW AS AGENT WORKING MEMORY ║
╚══════════════════════════════════════════════════════════════════════════════╝
TIME ──────────────────────────────────────────────────────────────────────▶
┌──────────────┬──────────────┬────────────────┬────────────┬──────────────┐
│ SYSTEM │ USER │ AGENT │ TOOL │ AGENT │
│ PROMPT │ MESSAGE │ THOUGHT │ RESULT │ RESPONSE │
│ │ │ (reasoning) │ │ │
│ "You are a │ "What is │ <think> │ {"temp": │ "The current │
│ weather │ the weather │ I need to │ 22, │ temperature │
│ assistant │ in Paris │ call the │ "unit": │ in Paris │
│ ..." │ today?" │ weather API │ "C", │ is 22°C and │
│ │ │ for Paris... │ "cond": │ cloudy." │
│ │ │ </think> │ "cloudy"} │ │
│ ~200 tokens │ ~15 tokens │ ~80 tokens │ ~40 tokens │ ~25 tokens │
└──────────────┴──────────────┴────────────────┴────────────┴──────────────┘
▲ ▲ ▲ ▲ ▲
└───────────────┴───────────────┴───────────────┴─────────────┘
│
At each generation step:
Full self-attention runs over the
ENTIRE context simultaneously.
Cost: O(n²) in total context length.
WHAT THIS MEANS FOR AGENTS:
✓ Tool results are just tokens - the model attends to them like any text
✓ Reasoning traces are visible - chain-of-thought shapes next generation
✓ Long task history - "memory" without any separate mechanism
⚠ Context fills up - very long loops need summarization/offload
⚠ O(n²) attention cost - longer context = quadratically more compute
KEY INSIGHT: There is no "working memory" separate from the context.
The context window IS the agent's entire cognitive state.
Pour un agent, la fenêtre représente un buffer plat et ordonné de tokens, et chaque étape de génération prend en compte l’ensemble de ce buffer, ce qui permet de garder à portée de main tout ce qui s’est produit jusqu’à la limite fixée. La fenêtre constitue la mémoire de travail de l’agent, l’attention en est le mécanisme de raisonnement et la boucle des tokens suivants en est la boucle d’action. L’intelligence artificielle agente n’avait pas besoin d’une nouvelle architecture ; il suffisait de se rendre compte que le transformateur, à une échelle suffisamment grande, pouvait déjà assurer cette capacité d’action.
Dans la pratique, les agents créés en 2026 ont rarement recours uniquement à la fenêtre de travail elle-même. Pour pouvoir effectuer des tâches longues, ils y ajoutent une mémoire externe : des fichiers de travail temporaire, une couche de récupération ou une base de connaissances que l’agent met à jour régulièrement. Cela ne contredit pas ce qui a été dit précédemment, car la mémoire externe n’affecte le modèle que lorsqu’elle est lu à nouveau dans la fenêtre de travail. Elle élargit le buffer sans le remplacer, et l’attention du transformateur sur ce contexte reste le seul endroit où se produit la réflexion.
Où en est la recherche
Les performances des transformateurs suivent des lois de puissance prévisibles en ce qui concerne les paramètres, les données d’entraînement et les ressources de calcul, ce qui offre aux chercheurs une feuille de route. Les recherches avancent dans plusieurs directions :
- Architectures efficaces qui réduisent le coût quadratique de l’attention, grâce au Flash Attention, à l’attention sparse et à l’attention linéaire.
Tous ces éléments reposent sur la base des transformers, ce qui permet de les comprendre plus facilement.
Le tableau ci-dessous rassemble chaque composant en une vue unique, indiquant le problème qu’il résout, son fonctionnement et ses principales caractéristiques :
| Component | Problem it Solves | Core Mechanism | Key Properties |
|-----------|------------------|----------------|----------------|
| **Tokenization** | Text is not natively numeric | Subword BPE/WordPiece splitting | Vocabulary ≈ 30k–100k; subwords handle rare terms |
| **Embeddings** | Discrete IDs have no geometry | $\mathbf{e}_t = E[t] \in \mathbb{R}^{d_{\text{model}}}$ | Semantic similarity → geometric proximity |
| **Positional Encoding** | Parallel attention loses token order | sin/cos at different frequencies (or RoPE) | Multi-scale; encodes absolute and relative position |
| **Self-Attention** | Long-range deps, sequential bottleneck | $\text{softmax}(QK^\top/\sqrt{d_k})V$ | $O(n^2)$ but parallel; dynamic contextual reps |
| **Query/Key/Value** | Separating "what I seek" from "what I offer" | Three separate learned linear projections | Relevance ≠ similarity; flexible dependency modeling |
| **Multi-Head Attention** | Single head captures only one relationship type | $h$ parallel heads, concatenated + $W^O$ | Simultaneously captures syntactic, semantic, positional |
| **Encoder** | Understanding input in full bidirectional context | Full self-attention, no masking | Bidirectional; rich contextualized representations |
| **Decoder** | Generating output autoregressively | Causal self-attention + cross-attention | Predicts one token at a time; teacher-forcing in training |
| **Cross-Attention** | Connecting generation to input understanding | Q from decoder, K/V from encoder | Enables encoder→decoder communication |
| **Feed-Forward Network** | Per-token computation + factual storage | $\text{GeLU}(\mathbf{x}W_1)\,W_2$ per token | Position-wise; stores factual associations in weights |
| **Residual Connections** | Vanishing gradients in deep networks | $\mathbf{h} = \text{SubLayer}(\mathbf{x}) + \mathbf{x}$ | Creates gradient highway; enables 100+ layer models |
| **Pre-LayerNorm** | Unstable activations in deep networks | Normalize before each sublayer | Stable training; standard in all modern transformers |
Ce qui a été abordé, et où aller ensuite
Les éléments s’assemblent comme suit. Une attention parallèle fonctionne mieux qu’un traitement étape par étape et permet de capturer des dépendances éloignées de manière plus efficace, c’est pourquoi les transformateurs ont remplacé les modèles séquentiels. Les données circulent du texte vers les tokens, puis vers les embeddings, l’encodage positionnel, l’attention et les couches feed-forward, avant de reprendre le cycle. L’auto-attention est l’opération centrale : chaque token prête attention à tous les autres grâce à des projections Q, K et V apprises, comme dans Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. Plusieurs têtes permettent de capturer différents types de motifs, l’encodage positionnel restaure l’ordre, et la conception encodeur-décodeur favorise à la fois la compréhension et la génération. Les couches feed-forward stockent les connaissances, les liens résiduels permettent une plus grande profondeur, et Pre-LayerNorm assure la stabilité de l’entraînement. La prédiction du token suivant à grande échelle génère des capacités émergentes, la fenêtre de contexte sert de mémoire de travail à l’agent, et l’architecture fr
Un article de traduction de 2017 est à l’origine des systèmes les plus avancés d’aujourd’hui.Pour aller plus loin, un plan en étapes s’avère efficace.
Les deux premières semaines : les mathématiques. Suivez la série de Andrej Karpathy intitulée « Neural Networks: Zero to Hero » sur YouTube, en particulier la vidéo qui construit GPT à partir de zéro. Ensuite, écrivez une couche d’auto-attention simple en NumPy. Les concepts s’impriment mieux une fois qu’on les a calculés manuellement.
Les semaines trois et quatre : les articles scientifiques. Lisez « Attention Is All You Need » (Vaswani et al., 2017), qui est désormais accessible, ainsi que l’article sur BERT (Devlin et al., 2018), l’article sur GPT-3 intitulé « Language Models are Few-Shot Learners » (Brown et al., 2020) et « Scaling Laws for Neural Language Models » (Kaplan et al., 2020).
Deuxième mois : pratique avec des bibliothèques et des API. La bibliothèque Hugging Face transformers permet d’utiliser ces modèles depuis Python avec peu de configuration. Affinez BERT ou un petit modèle à poids ouverts comme une variante de Llama ou Qwen pour une tâche de classification. Ensuite, accédez à un modèle de pointe, que ce soit Claude Sonnet 5 ou l’un des modèles GPT-5, via les SDK Python d’Anthropic ou d’OpenAI. Faire les deux relie la théorie à la pratique, car les mêmes principes des transformateurs sont visibles tant dans les modèles à poids ouverts que dans les modèles API de pointe.
Troisième mois : approfondissement d’un domaine. Choisissez l’un des frameworks d’agents (LangChain, LlamaIndex, ou une expérience pratique avec Claude Code ou Cursor pour observer le comportement des agents dans un outil de production réel), des transformeurs efficaces (Flash Attention, attention sparse et linéaire) ou l’affinement de modèles LLM avec LoRA et PEFT. Ici, l’approfondissement prime sur la largeur d’horizon.
En cours : restez à jour avec la recherche. Les sections cs.CL et cs.LG d’arXiv, le blog de Hugging Face, la page de recherche d’Anthropic ainsi que le forum AI Alignment Forum constituent de bonnes sources d’information. Le domaine évolue rapidement, mais les fondements présentés ci-dessus permettent de comprendre les nouveaux articles.
L’article sur les transformateurs compte une quinzaine de pages, et l’architecture qu’il décrit est suffisamment claire pour être mise en œuvre en une après-midi. Ce qu’il a déclenché, ainsi que ce que les améliorations continues permettent de découvrir, a changé la façon dont on perçoit les capacités des machines.