10. Transformeurs
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 6) et le mécanisme d'attention (leçon 9), et elle réutilise la normalisation (leçon 4) et les connexions résiduelles (leçon 5).
10.1 Auto-attention et Q, K, V
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.
D'une seule matrice d'entrée (ici quatre tokens, « nous mangeons du pain »), trois projections apprises donnent à chaque token sa requête, sa clé et sa valeur. Ce qu'elles alimentent est encore grisé.
10.2 Attention par produit scalaire mis à l'échelle
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\).
Toute la couche en produits matriciels, formes comprises : \(QK^T/\sqrt{d_k}\) compare chaque token à tous les autres (\(n \times n\)), la softmax par ligne transforme les scores en poids, et la multiplication par \(V\) rend une ligne de sortie par token.
10.2.1 Pourquoi diviser par \(\sqrt{d_k}\)
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.
L'unité jusqu'ici : une seule tête d'attention par produit scalaire normé, déjà à sa place. Le reste du bloc est encore grisé.
10.3 Attention multi-têtes
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.
Étape 2 : plusieurs têtes tournent en parallèle sur leurs propres projections, et leurs sorties sont concaténées puis mélangées par \(W^O\). La sous-couche multi-têtes est complète.
10.4 Encodage positionnel
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.
Les encodages positionnels sinusoïdaux varient rapidement dans les dimensions basses et lentement dans les dimensions hautes, donnant à chaque position une signature multi-échelle unique.
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.
Étape 3 : le côté entrée. Les plongements de tokens entrent par une addition avec l'encodage positionnel, ce qui donne à l'attention son sens de l'ordre.
10.5 Le bloc de Transformeur
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) }\]
Le bloc assemblé : l'auto-attention multi-têtes, puis le réseau à propagation avant par position, chacun enveloppé dans une connexion résiduelle et une normalisation par couche. Empilé \(N\) fois, c'est le Transformeur.
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 de la leçon 1 :
\[\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 5, de sorte que la sous-couche n'a qu'à apprendre une correction de son entrée. La normalisation par couche (leçon 4) 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 |
10.6 L'architecture encodeur-décodeur
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.
Le Transformeur complet : une pile de blocs encodeurs et une pile de blocs décodeurs reliées par l'attention croisée.
10.6.1 Variantes
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.
L'attention et le Transformeur étant maintenant acquis, l'arc du cours est complet : du simple perceptron à l'architecture derrière les modèles de fondation d'aujourd'hui. Pour faire passer un modèle entraîné du notebook à un service de production fiable, poursuivez avec le cours MLOps.
Suivant : Vue d'ensemble du cours