Le Transformeur remplace la récurrence par la seule attention. Il traite en parallèle une séquence entière de plongements de tokens, ce qui permet à chaque token de porter attention à tous les autres au moyen de requêtes, de clés et de valeurs apprises. Cette leçon construit l'architecture à partir de l'auto-attention, en supposant connus les plongements (leçon 12) et le mécanisme d'attention (leçon 15), et elle réutilise la normalisation (leçon 8) et les connexions résiduelles (leçon 11).

- Projeter les plongements de tokens en requêtes $Q$, clés $K$ et valeurs $V$ à l'aide de matrices apprises.

- Définir l'attention par produit scalaire mis à l'échelle et expliquer le facteur d'échelle $1/\sqrt{d_k}$.

- Exécuter plusieurs têtes d'attention en parallèle et les combiner par l'attention multi-têtes.

- Injecter l'ordre dans une opération ensembliste au moyen d'encodages positionnels.

- Assembler un bloc de Transformeur à partir de connexions résiduelles et de la normalisation par couche.

- Placer le bloc dans la pile encodeur-décodeur et nommer ses variantes encodeur seul et décodeur seul.

Une séquence de $n$ tokens est représentée par une matrice de plongements $X \in \mathbb{R}^{n \times d}$, une ligne par token. L'auto-attention permet à chaque token de recueillir de l'information auprès des autres en posant une question (une requête), en la comparant à l'étiquette de chaque token (une clé) et en en lisant le contenu (une valeur).

À partir de la même entrée $X$, nous formons trois projections à l'aide de matrices apprises $W^Q, W^K \in \mathbb{R}^{d \times d_k}$ et $W^V \in \mathbb{R}^{d \times d_v}$ :

$$\boxed{ Q = X W^Q, \quad K = X W^K, \quad V = X W^V }$$

*Remarque :* les projections sont ici les seuls paramètres appris, et les trois mêmes matrices sont partagées entre toutes les positions. Comme un token est comparé à tous les autres, l'opération capture les dépendances à longue portée en une seule étape, contrairement à une récurrence qui doit propager l'information une position à la fois.

Chaque requête est comparée à toutes les clés par un produit scalaire, ce qui donne une matrice $n \times n$ de scores bruts. Les scores sont mis à l'échelle, transformés en poids par un softmax appliqué ligne par ligne, puis utilisés pour moyenner les valeurs :

$$\boxed{ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left( \frac{Q K^{T}}{\sqrt{d_k}} \right) V }$$

La ligne $i$ du softmax est une distribution de probabilité sur tous les tokens, si bien que la ligne $i$ de la sortie est une moyenne pondérée des vecteurs de valeurs, pondérée par la pertinence de chaque token vis-à-vis du token $i$.

Si les composantes de $q$ et $k$ sont indépendantes, de moyenne nulle et de variance unité, le produit scalaire $q^{T} k = \sum_{j=1}^{d_k} q_j k_j$ a une variance $d_k$, de sorte que sa magnitude typique croît comme $\sqrt{d_k}$.

$$\boxed{ \mathrm{Var}\!\left(q^{T} k\right) = d_k \quad\Rightarrow\quad \frac{q^{T} k}{\sqrt{d_k}} \text{ a une variance unité} }$$

Des scores élevés poussent le softmax dans un régime saturé où un poids est proche de $1$ et les autres proches de $0$, régime dans lequel le gradient du softmax est minuscule. Diviser par $\sqrt{d_k}$ maintient les logits à une échelle modérée, ce qui garde les gradients du softmax en bonne santé et stabilise l'entraînement.

Un unique calcul d'attention contraint chaque relation à être lue à travers un seul sous-espace de dimension $d_k$. L'attention multi-têtes exécute $h$ opérations d'attention en parallèle, chacune avec ses propres projections, de sorte que différentes têtes peuvent se spécialiser (l'une sur la syntaxe, une autre sur la coréférence, et ainsi de suite).

La tête $i$ projette les entrées avec ses propres matrices $W_i^{Q}, W_i^{K}, W_i^{V}$ et applique l'attention par produit scalaire mis à l'échelle :

$$\boxed{ \mathrm{head}_i = \mathrm{Attention}\!\left(Q W_i^{Q}, K W_i^{K}, V W_i^{V}\right) }$$

Les têtes sont concaténées le long de l'axe des caractéristiques et mélangées par une projection de sortie $W^{O}$ :

$$\boxed{ \mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head}_1, \dots, \mathrm{head}_h)\, W^{O} }$$

*Remarque :* la largeur par tête est habituellement fixée à $d_k = d_v = d / h$, si bien que la concaténation revient à la largeur $d$ et que le coût total égale celui d'une seule tête de pleine largeur. Les têtes sont indépendantes et calculées en parallèle, ce qui explique en partie pourquoi les Transformeurs s'entraînent efficacement sur le matériel moderne.

L'attention traite son entrée comme un ensemble : permuter les lignes de $X$ permute la sortie de la même manière, l'opération est donc indifférente à l'ordre. Le langage ne l'est pas, la position doit donc être fournie explicitement. Le Transformeur original ajoute aux plongements un encodage sinusoïdal fixe, en utilisant une fréquence différente par dimension de caractéristique :

$$\boxed{ PE_{(pos,\, 2i)} = \sin\!\left(\frac{pos}{10000^{2i/d}}\right), \quad PE_{(pos,\, 2i+1)} = \cos\!\left(\frac{pos}{10000^{2i/d}}\right) }$$

Ici, $pos$ est la position du token et $i$ indexe la dimension de caractéristique. Les dimensions basses varient rapidement avec la position et les dimensions hautes varient lentement, de sorte que le vecteur encode la position à travers de nombreuses échelles. L'encodage est ajouté au plongement du token avant le premier bloc.

*Remarque :* les sinusoïdes permettent d'écrire un décalage relatif $PE_{pos+k}$ comme une fonction linéaire de $PE_{pos}$, de sorte que le modèle peut apprendre à porter attention par décalage relatif. Les encodages sont fixes (non appris) et s'étendent à des longueurs de séquence non vues pendant l'entraînement. De nombreux modèles ultérieurs les remplacent par des schémas de position appris ou relatifs.

Chaque sous-couche est enveloppée dans une connexion résiduelle suivie d'une normalisation par couche, ce qui maintient la circulation des gradients à travers des piles profondes et stabilise l'échelle des activations :

$$\boxed{ x \leftarrow \mathrm{LayerNorm}\!\left(x + \mathrm{Sublayer}(x)\right) }$$

Un bloc enchaîne deux sous-couches selon ce motif. La première est l'auto-attention multi-têtes (les tokens échangent de l'information). La seconde est un réseau à propagation avant appliqué par position, un MLP à deux couches appliqué indépendamment à chaque position, avec la notation utilisée depuis la leçon 12 :

$$\boxed{ \mathrm{FFN}(x) = g\!\left(x W_1 + b_1\right) W_2 + b_2 }$$

avec une non-linéarité $g$ (ReLU ou GELU) et une largeur interne plusieurs fois plus grande que $d$.

*Remarque :* la connexion résiduelle réutilise le raccourci identité de la leçon 11, de sorte que la sous-couche n'a qu'à apprendre une correction de son entrée. La normalisation par couche (leçon 8) normalise selon la dimension des caractéristiques pour chaque token, ce qui convient mieux aux séquences de longueur variable que la normalisation par lot. La forme ci-dessus correspond au placement post-norm original. De nombreuses implémentations modernes utilisent le pré-norm, $x \leftarrow x + \mathrm{Sublayer}(\mathrm{LayerNorm}(x))$, qui s'entraîne de façon plus stable à grande profondeur.

| Composant | Rôle | Agit selon |

| --- | --- | --- |

| Attention multi-têtes | mélanger l'information entre les tokens | la séquence |

| Réseau à propagation avant | transformer chaque token de façon non linéaire | les caractéristiques |

| Connexion résiduelle | préserver un chemin de gradient | la profondeur |

| Normalisation par couche | stabiliser l'échelle des activations | les caractéristiques par token |

Le Transformeur complet empile $N$ blocs identiques dans un encodeur et $N$ dans un décodeur. L'encodeur associe la séquence d'entrée à un ensemble de vecteurs de contexte. Chaque bloc décodeur comporte trois sous-couches : une auto-attention masquée sur les tokens générés jusqu'ici (le masque bloque l'attention vers les positions futures), une attention croisée dont les requêtes proviennent du décodeur et dont les clés et les valeurs proviennent de la sortie de l'encodeur, et un réseau à propagation avant. Une dernière couche linéaire suivie d'un softmax transforme les états du sommet du décodeur en une distribution sur le vocabulaire.

Toutes les tâches n'ont pas besoin des deux moitiés. Deux familles dominent la pratique :

| Variante | Structure | Attention | Usage typique |

| --- | --- | --- | --- |

| Encodeur seul (BERT) | pile d'encodeurs | bidirectionnelle | compréhension, classification, plongements |

| Décodeur seul (GPT) | pile de décodeurs | masquée (causale) | génération, prédiction autorégressive |

| Encodeur-décodeur (T5) | les deux piles | bidirectionnelle plus masquée | traduction, résumé |

*Remarque :* un modèle encodeur seul voit toute la séquence d'un coup, ce qui convient à l'étiquetage et à la recherche d'information. Un modèle décodeur seul masque le futur afin de pouvoir prédire le token suivant, ce qui correspond exactement au cadre de la génération de texte.

---