Lire « Attention Is All You Need » : l’article original du Transformer

En 2017, Vaswani et sept coauteurs, pour la plupart alors chez Google Brain ou Google Research, publient Attention Is All You Need et présentent le Transformer. L’article porte sur la traduction automatique, et son modèle est un encodeur–décodeur ; la plupart des grands modèles de langage actuels n’en conservent que la moitié décodeur. Ce contexte facilite la lecture : les auteurs se demandaient si un modèle de traduction pouvait se passer entièrement de récurrence et de convolution, pas comment construire un modèle conversationnel.

La suite reprend l’ordre de l’article. Les numéros de section, de tableau et d’équation renvoient à la version 7 sur arXiv. Les exemples chiffrés de l’attention elle-même se trouvent dans Mécanisme d'attention ; les composants modernes comme RMSNorm, RoPE, GQA et SwiGLU sont traités dans Transformers : architecture originale et blocs modernes et ne sont pas repris ici.

Le problème de 2017 : la récurrence fait attendre l’entraînement

La section 1 part de l’état de l’art de l’époque : les réseaux récurrents, LSTM et GRU en tête, dominaient la modélisation du langage et la traduction automatique. Un modèle récurrent calcule position après position : l’état caché $h_t$ dépend de $h_{t-1}$ et de l’entrée à la position $t$. Les auteurs soulignent que ce calcul intrinsèquement séquentiel empêche toute parallélisation au sein d’un exemple d’entraînement. Le problème s’aggrave avec la longueur des séquences, puisque la mémoire limite aussi le nombre d’exemples par lot. Les astuces de factorisation et le calcul conditionnel avaient amélioré l’efficacité, mais la contrainte fondamentale du calcul séquentiel demeurait.

L’attention faisait déjà partie des modèles de traduction. Elle relie directement deux positions quelle que soit leur distance, mais on l’employait presque toujours avec un réseau récurrent. L’article propose de supprimer complètement la récurrence et de s’appuyer uniquement sur l’attention pour établir des dépendances globales entre l’entrée et la sortie.

La section 2 situe le Transformer par rapport à une autre famille de modèles qui réduisait déjà le calcul séquentiel. L’Extended Neural GPU, ByteNet et ConvS2S utilisent des convolutions pour calculer en parallèle les représentations de toutes les positions. Dans ces modèles, cependant, le nombre d’opérations nécessaires pour relier deux positions quelconques croît avec leur distance, linéairement pour ConvS2S et logarithmiquement pour ByteNet, ce qui rend les dépendances lointaines plus difficiles à apprendre. Le Transformer ramène ce nombre à une constante. Les auteurs en indiquent aussi le prix : moyenner les positions pondérées par l’attention réduit la « résolution effective », et c’est ce que l’attention multi-têtes doit compenser.

L’article vise donc deux choses à la fois : la part de l’entraînement qui peut s’exécuter en parallèle, et la longueur du chemin qu’un signal doit parcourir entre deux positions éloignées. Le tableau 1 de la section 4 exprime ces deux points en termes de complexité.

L’architecture telle que l’article la définit

La section 3 reprend le cadre général des modèles de transduction de séquences. L’encodeur transforme une séquence de symboles d’entrée $(x_1,\dots,x_n)$ en représentations continues $\mathbf z=(z_1,\dots,z_n)$. À partir de $\mathbf z$, le décodeur produit une séquence de sortie $(y_1,\dots,y_m)$ symbole par symbole. Chaque étape est autorégressive : les symboles déjà produits servent d’entrée supplémentaire pour générer le suivant.

Voir l’image en grand

L’encodeur est à gauche, le décodeur à droite ; le N× à côté de chaque pile signifie que la même couche est répétée $N=6$ fois. Les flèches qui contournent chaque sous-couche sont des connexions résiduelles, et « Add & Norm » signifie qu’on additionne d’abord, puis qu’on applique la normalisation de couche. Des trois entrées de la sous-couche d’attention centrale du décodeur, deux viennent de la sortie de l’encodeur et une du décodeur lui-même.

Vaswani et al., Attention Is All You Need (2017), figure 1. © Google. · Autorisation de reproduction

La section 3.1 décrit les deux piles. L’encodeur compte $N=6$ couches identiques, chacune formée de deux sous-couches : une auto-attention multi-têtes et un réseau feed-forward entièrement connecté appliqué position par position. Le décodeur compte lui aussi $N=6$ couches et ajoute une troisième sous-couche, qui applique une attention multi-têtes à la sortie de la pile d’encodeurs.

Chaque sous-couche est entourée d’une connexion résiduelle suivie d’une normalisation de couche ; la sortie d’une sous-couche vaut donc

$$\operatorname{LayerNorm}\big(x+\operatorname{Sublayer}(x)\big).$$

La normalisation vient après l’addition résiduelle, un ordre qu’on appellera plus tard Post-Norm. Pour que ces additions soient possibles, toutes les sous-couches et les deux couches d’embedding produisent des sorties de dimension $d_{\text{model}}=512$.

L’auto-attention du décodeur est masquée pour qu’une position ne puisse pas regarder les positions suivantes. Combiné au décalage d’une position des embeddings de sortie, ce masque garantit que la prédiction pour la position $i$ ne dépend que des sorties connues aux positions inférieures à $i$. Pour apprendre au modèle à produire [A, B, EOS], par exemple, on donne au décodeur [BOS, A, B] : la position qui prédit B ne voit que BOS et A.

Trois usages de l’attention dans le modèle

La section 3.2.3 recense trois endroits où le modèle utilise l’attention multi-têtes. Le calcul est le même dans les trois cas ; seules changent la provenance des requêtes, des clés et des valeurs, et les positions visibles :

Usage	Requêtes issues de	Clés et valeurs issues de	Chaque position voit
Auto-attention de l’encodeur	Sortie de la couche précédente de l’encodeur	Même source	Toutes les positions de la couche précédente de l’encodeur
Auto-attention du décodeur	Sortie de la couche précédente du décodeur	Même source	Les positions jusqu’à elle-même incluse
Attention encodeur–décodeur	Sortie de la couche précédente du décodeur	Sortie de l’encodeur	Toutes les positions de la séquence d’entrée

La troisième est ce qu’on appelle habituellement l’attention croisée ; elle reprend l’attention encodeur–décodeur typique des modèles séquence-à-séquence antérieurs. Le masque du décodeur est appliqué à l’intérieur de l’attention par produit scalaire mis à l’échelle : avant le softmax, toute valeur correspondant à une connexion interdite est fixée à $-\infty$, si bien que son poids vaut exactement zéro.

Attention par produit scalaire mis à l’échelle : pourquoi réduire les scores

La section 3.2 définit l’attention sobrement : elle associe à une requête et à un ensemble de paires clé–valeur une sortie, somme pondérée des valeurs, où chaque poids est calculé par une fonction de compatibilité entre la requête et la clé correspondante. La section 3.2.1 prend le produit scalaire comme fonction de compatibilité. En regroupant plusieurs requêtes dans une matrice $Q$, et les clés et valeurs dans $K$ et $V$, on obtient l’équation (1) :

$$\operatorname{Attention}(Q,K,V)=\operatorname{softmax}\!\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V.$$

$d_k$ est la dimension des requêtes et des clés, $d_v$ celle des valeurs. Les deux fonctions d’attention les plus courantes à l’époque étaient l’attention additive et l’attention par produit scalaire ; la seconde ne diffère de l’équation ci-dessus que par le facteur $1/\sqrt{d_k}$. Leur complexité théorique est comparable, mais le produit scalaire s’appuie sur des multiplications matricielles très optimisées et s’avère bien plus rapide et plus économe en mémoire.

Pourquoi ce facteur ? Des expériences citées par l’article montrent que les deux mécanismes se valent pour de petites valeurs de $d_k$, mais que l’attention additive l’emporte sur le produit scalaire non mis à l’échelle quand $d_k$ grandit. Les auteurs soupçonnent que, pour $d_k$ grand, les produits scalaires prennent de grandes valeurs et poussent le softmax vers des régions où ses gradients sont extrêmement faibles. Une note de bas de page donne la raison : si les composantes de $q$ et $k$ sont des variables aléatoires indépendantes de moyenne 0 et de variance 1, alors $q\cdot k=\sum_{i=1}^{d_k}q_ik_i$ a une moyenne de 0 et une variance de $d_k$. Diviser par $\sqrt{d_k}$ ramène la variance à 1.

Avec le $d_k=64$ de l’article, l’écart type d’un produit scalaire vaut environ 8. Supposons deux clés avec des scores non mis à l’échelle de 8 et 0. Le softmax attribue à la première un poids d’environ 0,9997, presque une distribution one-hot, et sa dérivée $p(1-p)$ tombe à environ 0,0003. Divisés par 8, les scores deviennent 1 et 0, les poids environ 0,73 et 0,27, et la dérivée environ 0,20. Ce n’est qu’un calcul à la main. L’article présente l’explication par les gradients comme une hypothèse et ne lui consacre aucune expérience.

La figure ci-dessous applique le même calcul à une phrase de sept mots. Pour que l’arithmétique reste lisible, ses vecteurs n’ont que deux dimensions : les scores y sont divisés par $\sqrt2$, alors que l’article divise par $\sqrt{64}=8$. Activez le masque causal pour voir comment l’auto-attention du décodeur cache les mots suivants, ou passez à « Les deux têtes » pour un avant-goût de la concaténation multi-têtes de la section suivante.

L’attention dans une phrase

Choisissez le mot qui interroge (la requête). Chaque étape ajoute une partie du calcul.

Mot requête

Masque causal (cacher les mots suivants)

Chaque ligne est une requête, chaque colonne une clé. Chaque ligne est un softmax distinct qui totalise 100 %. Sélectionnez une ligne pour faire de ce mot la requête.

q(il) = [2.2, 0]

Clé	k	q·k/√2	Poids
Le	[0.2, 0]	0.31	4.0%
chat	[2, 0.4]	3.11	66%
dormait	[0.3, 1.6]	0.47	4.7%
car	[0, 0.2]	0.00	2.9%
il	[1, 0.3]	1.56	14%
était	[0.1, 0.5]	0.16	3.4%
fatigué	[0.4, 1.4]	0.62	5.5%

Tête 1 : le sens · Somme pondérée

Sortie o₁ = Σ w·v = [2.67, 1.16]

Tête 1 : le sens · Toutes les requêtes

Les vecteurs sont choisis à la main pour rendre deux motifs lisibles. Dans un modèle entraîné, les têtes sont rarement aussi nettes.

Attention multi-têtes : huit têtes de 64 dimensions

Plutôt que d’appliquer une seule fonction d’attention à des requêtes, clés et valeurs de dimension $d_{\text{model}}$, la section 3.2.2 les projette $h$ fois, avec des projections apprises différentes, vers $d_k$, $d_k$ et $d_v$ dimensions. Elle calcule l’attention en parallèle sur chaque projection, concatène les $h$ sorties de dimension $d_v$, puis applique une dernière projection :

$$\begin{aligned} \operatorname{MultiHead}(Q,K,V)&=\operatorname{Concat}(\mathrm{head}_1,\dots,\mathrm{head}_h)\,W^O,\\ \mathrm{head}_i&=\operatorname{Attention}(QW_i^Q,\,KW_i^K,\,VW_i^V). \end{aligned}$$

Les matrices de projection ont pour formes $W_i^Q,W_i^K\in\mathbb R^{d_{\text{model}}\times d_k}$, $W_i^V\in\mathbb R^{d_{\text{model}}\times d_v}$ et $W^O\in\mathbb R^{hd_v\times d_{\text{model}}}$. L’article utilise $h=8$ têtes, chacune avec $d_k=d_v=d_{\text{model}}/h=64$.

Suivons les formes pour une phrase de 10 tokens. L’entrée mesure $10\times512$. Chaque tête la projette en requêtes, clés et valeurs de $10\times64$, calcule une matrice de poids $10\times10$ et produit une sortie $10\times64$. Concaténer les huit têtes redonne $10\times512$, que l’on multiplie par la matrice $512\times512$ $W^O$. Comme chaque tête est plus petite, le coût total reste proche de celui d’une attention à une seule tête en pleine dimension. Avec ces formes, une sous-couche d’attention multi-têtes contient quatre matrices de $512\times512$, soit 1 048 576 poids.

L’argument des auteurs est que l’attention multi-têtes permet au modèle de prêter attention conjointement à des informations issues de sous-espaces de représentation différents, à des positions différentes ; avec une seule tête, la moyenne efface ces distinctions. Les lignes (A) du tableau 3 mettent cette affirmation à l’épreuve, comme on le verra plus bas.

Les trois autres composants

Réseaux feed-forward position par position

Selon la section 3.3, chaque couche de l’encodeur et du décodeur contient aussi un réseau feed-forward entièrement connecté, appliqué à chaque position séparément et de manière identique. Il se compose de deux transformations linéaires séparées par une ReLU, équation (2) :

$$\operatorname{FFN}(x)=\max(0,\,xW_1+b_1)\,W_2+b_2.$$

Les positions d’une même couche partagent leurs paramètres, tandis que chaque couche a les siens ; l’article note qu’on peut aussi y voir deux convolutions de noyau 1. L’entrée et la sortie ont $d_{\text{model}}=512$ dimensions, la couche interne $d_{ff}=2048$. À cette taille, $W_1$ et $W_2$ totalisent $2\times512\times2048=2\,097\,152$ poids, environ le double des poids de projection d’une sous-couche d’attention. Le titre affirme que l’attention suffit, pourtant, dans chaque couche de l’encodeur, le FFN compte deux fois plus de poids que l’attention ; il faut la seconde sous-couche d’attention du décodeur pour que les deux s’équilibrent à peu près. L’attention fait circuler l’information entre les positions ; le FFN traite ensuite chaque position isolément.

Embeddings et partage des poids

La section 3.4 utilise des embeddings appris pour convertir les tokens d’entrée et de sortie en vecteurs de dimension $d_{\text{model}}$, et la transformation linéaire apprise habituelle suivie d’un softmax pour convertir la sortie du décodeur en probabilités du token suivant. L’article partage une même matrice de poids entre les deux couches d’embedding et la transformation linéaire qui précède le softmax ; dans les couches d’embedding, il multiplie ces poids par $\sqrt{d_{\text{model}}}$ (environ 22,6). L’article ne justifie pas ce facteur.

Partager une même table d’embeddings entre langue source et langue cible suppose que les deux utilisent le même vocabulaire. C’est le cas pour l’anglais–allemand : la section 5.1 indique que les phrases sont encodées par byte-pair encoding (BPE), avec un vocabulaire source–cible partagé d’environ 37 000 tokens. Les pratiques générales de tokenisation et de vocabulaire sont décrites dans Tokenisation et représentations du texte dans un modèle.

Encodage positionnel sinusoïdal

Sans récurrence ni convolution, le modèle a besoin d’une autre source d’information sur la position relative ou absolue des tokens pour exploiter leur ordre. La section 3.5 ajoute des « encodages positionnels » aux embeddings d’entrée, à la base des piles de l’encodeur et du décodeur. Ces encodages ont la même dimension $d_{\text{model}}$ que les embeddings, ce qui permet de les additionner. L’article utilise des sinus et cosinus de fréquences différentes :

$$\begin{aligned} PE_{(pos,\,2i)}&=\sin\!\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right),\\ PE_{(pos,\,2i+1)}&=\cos\!\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right). \end{aligned}$$

$pos$ désigne la position et $i$ la dimension. Chaque dimension de l’encodage correspond à une sinusoïde, sinus pour les dimensions paires et cosinus pour les impaires, chaque paire partageant une fréquence ; les longueurs d’onde forment une progression géométrique de $2\pi$ à $10000\cdot2\pi$. À la position 1, la première paire de dimensions vaut $\sin 1\approx0{,}841$ et $\cos 1\approx0{,}540$. Pour la dernière paire ($i=255$), le dénominateur vaut environ 9647 et le sinus n’atteint qu’environ 0,0001. Les premières dimensions varient vite avec la position, les dernières lentement ; ensemble, elles distinguent un grand nombre de positions.

Les auteurs ont choisi cette fonction parce qu’ils supposaient qu’elle permettrait au modèle d’apprendre facilement à porter attention selon la position relative : pour tout décalage fixe $k$, $PE_{pos+k}$ s’écrit comme une fonction linéaire de $PE_{pos}$. Pour une seule fréquence $\omega$, c’est la formule d’addition des angles. Passer de $(\sin\omega p,\cos\omega p)$ à $(\sin\omega(p+k),\cos\omega(p+k))$ revient à appliquer une matrice de rotation $2\times2$ qui ne dépend que de $k$.

L’article a aussi essayé des embeddings positionnels appris et obtenu des résultats presque identiques (tableau 3, ligne (E)). Il a gardé la version sinusoïdale parce qu’elle « pourrait » permettre au modèle d’extrapoler à des séquences plus longues que celles vues à l’entraînement. C’est une attente des auteurs ; l’article ne présente aucune expérience d’extrapolation.

Pourquoi l’auto-attention : lire le tableau 1

La section 4 compare les couches d’auto-attention aux couches récurrentes et convolutives sur une même tâche : transformer une séquence de longueur variable $(x_1,\dots,x_n)$ en une autre de même longueur $(z_1,\dots,z_n)$, avec $x_i,z_i\in\mathbb R^d$. Elle retient trois critères : la complexité de calcul totale par couche ; la part du calcul parallélisable, mesurée par le nombre minimal d’opérations séquentielles ; et la longueur du chemin entre dépendances lointaines dans le réseau. Plus les chemins que doivent parcourir les signaux, en propagation avant comme arrière, sont courts, plus les dépendances lointaines sont faciles à apprendre.

Dans le tableau 1, $n$ est la longueur de la séquence, $d$ la dimension de représentation, $k$ la taille du noyau de convolution et $r$ la taille du voisinage de l’auto-attention restreinte :

Type de couche	Complexité par couche	Opérations séquentielles	Longueur maximale de chemin
Auto-attention	$O(n^2\cdot d)$	$O(1)$	$O(1)$
Récurrente	$O(n\cdot d^2)$	$O(n)$	$O(n)$
Convolutive	$O(k\cdot n\cdot d^2)$	$O(1)$	$O(\log_k n)$
Auto-attention restreinte	$O(r\cdot n\cdot d)$	$O(1)$	$O(n/r)$

Commençons par les deux dernières colonnes. Une couche d’auto-attention relie toutes les positions avec un nombre constant d’opérations séquentielles ; une couche récurrente en demande $O(n)$. La position 50 doit attendre les 49 états qui la précèdent, et un signal parti du mot 1 traverse 49 mises à jour d’état avant d’atteindre le mot 50. En auto-attention, ces deux positions sont reliées directement au sein d’une seule couche.

Passons à la complexité. Les couches d’auto-attention sont plus rapides que les couches récurrentes quand la longueur $n$ de la séquence est inférieure à la dimension $d$. Les auteurs notent que c’est le plus souvent le cas pour les représentations de phrases des meilleurs modèles de traduction, à base de word-pieces ou de byte-pairs. Prenons $d=512$ : pour $n=50$, $n^2d=1\,280\,000$ contre $nd^2=13\,107\,200$, soit un ordre de grandeur de moins pour l’auto-attention ; pour $n=2000$, le premier terme passe à $2{,}048\times10^9$, environ quatre fois le second. Le $O(1)$ du tableau signifie que le travail d’une couche peut s’exécuter en parallèle, pas que l’auto-attention est bon marché. Pour les séquences très longues, les auteurs proposent de restreindre l’attention à un voisinage de taille $r$ centré sur la position de sortie, au prix d’une longueur maximale de chemin portée à $O(n/r)$, et renvoient cette piste à des travaux ultérieurs.

La ligne des convolutions mérite une explication. Une seule couche convolutive de largeur de noyau $k\lt n$ ne relie pas toutes les paires de positions. Il faut pour cela empiler $O(n/k)$ couches avec des noyaux contigus, ou $O(\log_k n)$ avec des convolutions dilatées, ce qui allonge les chemins les plus longs. Les couches convolutives coûtent en général $k$ fois plus que les couches récurrentes. Les convolutions séparables réduisent la complexité à $O(k\cdot n\cdot d+n\cdot d^2)$, mais même avec $k=n$, cela équivaut à une couche d’auto-attention suivie d’une couche feed-forward position par position, soit exactement la combinaison retenue par le Transformer.

Les auteurs signalent un avantage secondaire : l’auto-attention pourrait rendre les modèles plus interprétables. Dans les visualisations de l’annexe, différentes têtes semblent apprendre des tâches différentes, et certaines paraissent suivre la structure syntaxique et sémantique des phrases ; plusieurs têtes de la couche 5, par exemple, relient « making » au lointain « more difficult ». Ce que prouvent réellement les poids d’attention est une autre question, traitée dans la partie consacrée à leur interprétation dans Mécanisme d'attention.

Configuration d’entraînement

La section 5 détaille l’entraînement. Les durées et les coûts d’entraînement du tableau 2 découlent directement du matériel et du nombre d’étapes décrits ici.

Données, matériel et durée

Section 5.1 : l’anglais–allemand utilise le jeu de données standard WMT 2014, environ 4,5 millions de paires de phrases, avec un vocabulaire BPE partagé d’environ 37 000 tokens. L’anglais–français utilise le jeu WMT 2014 anglais–français, bien plus grand, de 36 millions de phrases, avec un vocabulaire de 32 000 word-pieces. Les paires de phrases sont regroupées par longueur approximative, chaque lot contenant environ 25 000 tokens source et 25 000 tokens cible.

Section 5.2 : tous les modèles ont été entraînés sur une seule machine équipée de 8 GPU NVIDIA P100. Les modèles de base prenaient environ 0,4 seconde par étape et ont été entraînés pendant 100 000 étapes, soit environ 12 heures. Les grands modèles prenaient 1,0 seconde par étape et ont été entraînés pendant 300 000 étapes, soit environ 3,5 jours.

Optimiseur et préchauffage du taux d’apprentissage

La section 5.3 utilise Adam avec $\beta_1=0{,}9$, $\beta_2=0{,}98$ et $\epsilon=10^{-9}$. Le taux d’apprentissage varie avec l’étape d’entraînement $s$ selon l’équation (3), où $w$ est le nombre d’étapes de préchauffage :

$$\text{lrate}=d_{\text{model}}^{-0.5}\cdot\min\left(s^{-0.5},\ s\cdot w^{-1.5}\right).$$

Le taux augmente linéairement pendant les $w$ premières étapes, puis décroît proportionnellement à l’inverse de la racine carrée du numéro d’étape. L’article fixe $w=4000$. Avec $d_{\text{model}}=512$, le taux culmine à l’étape 4000 à $(512\times4000)^{-0{,}5}\approx7{,}0\times10^{-4}$ et n’est plus que d’environ $1{,}4\times10^{-4}$ à l’étape 100 000.

Régularisation

La section 5.4 décrit le dropout résiduel et le lissage des étiquettes. Le dropout résiduel s’applique à la sortie de chaque sous-couche avant qu’elle soit ajoutée à l’entrée de la sous-couche et normalisée, ainsi qu’aux sommes des embeddings et des encodages positionnels dans les deux piles. Le modèle de base utilise $P_{drop}=0{,}1$. Le lissage des étiquettes utilise $\epsilon_{ls}=0{,}1$ et déplace pendant l’entraînement une partie de la probabilité cible du bon token vers les autres. Selon l’article, il dégrade la perplexité, car le modèle apprend à être moins sûr de lui, mais améliore la précision et le score BLEU. Les lignes (D) du tableau 3 montrent cet effet.

Résultats

Traduction automatique : tableau 2

La section 6.1 rapporte les scores BLEU sur newstest2014. Voici les chiffres du tableau 2 ; le coût d’entraînement est exprimé en opérations en virgule flottante (FLOPs), et les cellules vides le sont aussi dans l’original :

Modèle	BLEU EN-DE	BLEU EN-FR	Coût EN-DE	Coût EN-FR
ByteNet	23,75
Deep-Att + PosUnk		39,2		$1{,}0\cdot10^{20}$
GNMT + RL	24,6	39,92	$2{,}3\cdot10^{19}$	$1{,}4\cdot10^{20}$
ConvS2S	25,16	40,46	$9{,}6\cdot10^{18}$	$1{,}5\cdot10^{20}$
MoE	26,03	40,56	$2{,}0\cdot10^{19}$	$1{,}2\cdot10^{20}$
Deep-Att + PosUnk Ensemble		40,4		$8{,}0\cdot10^{20}$
GNMT + RL Ensemble	26,30	41,16	$1{,}8\cdot10^{20}$	$1{,}1\cdot10^{21}$
ConvS2S Ensemble	26,36	41,29	$7{,}7\cdot10^{19}$	$1{,}2\cdot10^{21}$
Transformer (base)	27,3	38,1	$3{,}3\cdot10^{18}$	(fusionné avec la cellule de gauche)
Transformer (grand)	28,4	41,8	$2{,}3\cdot10^{19}$	(fusionné avec la cellule de gauche)

En anglais–allemand, le grand modèle dépasse de plus de 2,0 points BLEU les meilleurs résultats publiés jusque-là, ensembles compris, et atteint 28,4 ; même le modèle de base surpasse tous les modèles et ensembles publiés auparavant. En anglais–français, le grand modèle dépasse tous les modèles uniques publiés, pour moins d’un quart du coût d’entraînement du meilleur modèle précédent. Le grand modèle anglais–français utilisait un dropout de 0,1 au lieu des 0,3 habituels du grand modèle. Le score anglais–français comporte une incohérence : le résumé et le tableau 2 indiquent 41,8, alors que le texte de la section 6.1 indique 41,0.

La colonne des coûts est une estimation, pas une mesure. L’article multiplie la durée d’entraînement, le nombre de GPU et une estimation de la puissance soutenue en simple précision de chaque GPU, en retenant 9,5 TFLOPS pour un P100. Douze heures sur 8 GPU donnent environ $3{,}3\times10^{18}$ pour le modèle de base, et 3,5 jours environ $2{,}3\times10^{19}$ pour le grand modèle, ce qui correspond au tableau. Dans l’original, chaque Transformer n’a qu’un seul chiffre de coût, qui s’étend sur les colonnes anglais–allemand et anglais–français.

La même section précise le décodage. Les modèles de base font la moyenne des 5 derniers points de contrôle, enregistrés toutes les 10 minutes ; les grands modèles, des 20 derniers. La recherche en faisceau utilise une largeur de 4 et une pénalité de longueur $\alpha=0{,}6$. La longueur maximale de sortie vaut la longueur d’entrée plus 50, avec arrêt anticipé quand c’est possible.

Variantes du modèle : tableau 3

La section 6.2 modifie le modèle de base un aspect à la fois et l’évalue sur le jeu de développement anglais–allemand newstest2013, avec recherche en faisceau mais sans moyenne de points de contrôle. Les perplexités (PPL) sont calculées par word-piece et ne se comparent pas à des perplexités par mot. C’est pourquoi le BLEU du modèle de base vaut ici 25,8, à ne pas comparer directement aux 27,3 obtenus sur le jeu de test au tableau 2. Les valeurs non indiquées dans le tableau 3 sont celles du modèle de base :

Ligne	Modification	PPL (dev)	BLEU (dev)	Paramètres (×10⁶)
base	$N=6$, $d_{\text{model}}=512$, $d_{ff}=2048$, $h=8$, $d_k=d_v=64$, $P_{drop}=0{,}1$, $\epsilon_{ls}=0{,}1$, 100K étapes	4,92	25,8	65
(A)	$h=1$, $d_k=d_v=512$	5,29	24,9
(A)	$h=4$, $d_k=d_v=128$	5,00	25,5
(A)	$h=16$, $d_k=d_v=32$	4,91	25,8
(A)	$h=32$, $d_k=d_v=16$	5,01	25,4
(B)	$d_k=16$	5,16	25,1	58
(B)	$d_k=32$	5,01	25,4	60
(C)	$N=2$	6,11	23,7	36
(C)	$N=4$	5,19	25,3	50
(C)	$N=8$	4,88	25,5	80
(C)	$d_{\text{model}}=256$, $d_k=d_v=32$	5,75	24,5	28
(C)	$d_{\text{model}}=1024$, $d_k=d_v=128$	4,66	26,0	168
(C)	$d_{ff}=1024$	5,12	25,4	53
(C)	$d_{ff}=4096$	4,75	26,2	90
(D)	$P_{drop}=0{,}0$	5,77	24,6
(D)	$P_{drop}=0{,}2$	4,95	25,5
(D)	$\epsilon_{ls}=0{,}0$	4,67	25,3
(D)	$\epsilon_{ls}=0{,}2$	5,47	25,7
(E)	Embedding positionnel appris au lieu des sinusoïdes	4,92	25,7
grand	$N=6$, $d_{\text{model}}=1024$, $d_{ff}=4096$, $h=16$, $P_{drop}=0{,}3$, 300K étapes	4,33	26,4	213

Chaque groupe établit un point :

• (A) Nombre de têtes : le calcul reste constant pendant que varient le nombre de têtes et leurs dimensions. Une seule tête fait perdre 0,9 point BLEU par rapport au meilleur réglage, et la qualité baisse aussi avec trop de têtes.
• (B) Taille des clés : réduire $d_k$ dégrade la qualité. Les auteurs y voient l’indice qu’évaluer la compatibilité n’est pas simple et qu’une fonction plus élaborée que le produit scalaire pourrait aider.
• (C) Taille : les modèles plus grands font mieux, comme prévu.
• (D) Régularisation : le dropout aide beaucoup à éviter le surapprentissage ; sans lui, le BLEU tombe à 24,6. Supprimer le lissage des étiquettes donne une perplexité plus basse (4,67) mais fait baisser le BLEU de 25,8 à 25,3, comme l’annonce la section 5.4.
• (E) Encodage positionnel : embeddings positionnels appris et sinusoïdes donnent des résultats presque identiques.

Analyse syntaxique en constituants de l’anglais : tableau 4

Pour vérifier que le Transformer se généralise au-delà de la traduction, la section 6.3 l’applique à l’analyse syntaxique en constituants de l’anglais. La sortie de cette tâche est soumise à de fortes contraintes structurelles et nettement plus longue que l’entrée ; de plus, les modèles séquence-à-séquence récurrents n’avaient pas atteint l’état de l’art avec peu de données.

Les auteurs ont entraîné un Transformer à 4 couches avec $d_{\text{model}}=1024$. Un premier réglage n’utilise que la partie Wall Street Journal (WSJ) du Penn Treebank, environ 40 000 phrases d’entraînement, avec un vocabulaire de 16K. Un réglage semi-supervisé ajoute les corpus à haute confiance et BerkeleyParser, environ 17 millions de phrases, avec un vocabulaire de 32K. Seul un petit nombre d’expériences sur le jeu de développement de la section 22 a servi à choisir le dropout (d’attention et résiduel), les taux d’apprentissage et la largeur du faisceau ; tous les autres paramètres sont ceux du modèle de base de traduction anglais–allemand. À l’inférence, la longueur maximale de sortie passe à la longueur d’entrée plus 300, avec une largeur de faisceau de 21 et $\alpha=0{,}3$ dans les deux réglages.

Le tableau 4 donne le F1 sur la section 23 du WSJ :

Analyseur	Entraînement	F1 WSJ 23
Vinyals & Kaiser et al. (2014)	WSJ seul, discriminatif	88,3
Petrov et al. (2006)	WSJ seul, discriminatif	90,4
Zhu et al. (2013)	WSJ seul, discriminatif	90,4
Dyer et al. (2016)	WSJ seul, discriminatif	91,7
Transformer (4 couches)	WSJ seul, discriminatif	91,3
Zhu et al. (2013)	semi-supervisé	91,3
Huang & Harper (2009)	semi-supervisé	91,3
McClosky et al. (2006)	semi-supervisé	92,1
Vinyals & Kaiser et al. (2014)	semi-supervisé	92,1
Transformer (4 couches)	semi-supervisé	92,7
Luong et al. (2015)	multitâche	93,0
Dyer et al. (2016)	génératif	93,3

L’article conclut que, sans réglage propre à la tâche, le modèle fait mieux que tous les modèles publiés auparavant à l’exception de la Recurrent Neural Network Grammar (RNNG, Dyer et al. 2016). Ligne par ligne : avec le WSJ seul, 91,3 reste sous les 91,7 de la RNNG ; dans le groupe semi-supervisé, 92,7 est le meilleur score ; les résultats multitâche (93,0) et de la RNNG générative (93,3) sont plus élevés, mais reposent sur d’autres modes d’entraînement. Contrairement aux modèles séquence-à-séquence récurrents, le Transformer dépasse le BerkeleyParser (Petrov et al. 2006, 90,4) même entraîné sur les seules 40 000 phrases du WSJ.

Ce qui a tenu et ce qui a changé

Les calculs centraux de l’article ont pour l’essentiel survécu tels quels : la formule de l’attention par produit scalaire mis à l’échelle, la concaténation et la projection de sortie de l’attention multi-têtes, les connexions résiduelles, les couches feed-forward position par position et l’entraînement de toutes les positions en parallèle. Ce qui a changé tient surtout à la façon d’assembler ces pièces :

• Topologie : de nombreux grands modèles de langage ne conservent que la pile du décodeur, sans encodeur ni attention croisée. La visibilité du contexte et les têtes de sortie des trois familles sont décrites dans Encoder, Decoder et Encoder–Decoder ; les règles de génération token par token, dans Génération autorégressive et décodage.
• Place de la normalisation : Xiong et al. (2020) ont analysé l’agencement Post-LN de l’article. À l’initialisation, les gradients des paramètres proches de la couche de sortie sont grands, si bien qu’un taux d’apprentissage élevé rend l’entraînement instable ; ils expliquent ainsi la nécessité du préchauffage. Avec la normalisation déplacée à l’intérieur de la branche résiduelle (Pre-LN), un entraînement sans préchauffage atteint des résultats comparables. Les modèles modernes emploient couramment Pre-Norm et RMSNorm, comme le décrit la partie sur les blocs de Transformers.
• Information de position : après les sinusoïdes sont venus les positions absolues apprises, les biais de position relative et RoPE. RoPE encode la position absolue par une matrice de rotation tout en intégrant explicitement la dépendance à la position relative dans le calcul de l’auto-attention. Le tableau sur la position de Transformers compare où agit chaque méthode.
• Têtes et cache : lors d’une génération token par token, les clés et valeurs des positions antérieures sont mises en cache. L’attention multi-requêtes (MQA) et l’attention à requêtes groupées (GQA) font partager à plusieurs têtes de requête un nombre réduit de têtes clé/valeur pour réduire ce cache ; voir Variantes de l’attention et compression du cache KV.
• FFN : la ReLU cède souvent la place à GELU ou à des variantes à portes comme SwiGLU ; voir Activations et réseaux feed-forward à portes.
• Longueur des séquences : l’hypothèse du tableau 1, $n$ inférieur à $d$, ne tient plus pour les longs contextes, où le terme en $n^2$ devient le coût principal. Des noyaux comme FlashAttention abaissent le pic de mémoire, mais l’attention exacte reste quadratique en calcul. Les estimations détaillées de formes et de mémoire se trouvent dans Transformers.

Dans leur conclusion, les auteurs fixent trois pistes : appliquer le Transformer à d’autres modalités d’entrée et de sortie que le texte ; étudier une attention locale et restreinte pour traiter efficacement de grandes entrées et sorties comme les images, l’audio et la vidéo ; rendre la génération moins séquentielle. Le code d’entraînement et d’évaluation a été publié dans tensor2tensor.

Mes lectures · Les notes ouvertes sont mémorisées dans ce navigateur.