L’architecture du transformeur

L’attention et l’auto-attention a construit le mécanisme qui permet à chaque position de consulter toutes les autres. Un mécanisme n’est pas un modèle. Entre l’attention et un GPT opérationnel se logent quatre composants de plus, chacun résolvant un problème concret qui surgit quand on empile profondément des couches d’attention, plus une question de câblage.

Cet article assemble le bloc, déroule la normalisation de couche à la main, et finit en comptant les paramètres de GPT-2 small - pour retrouver le chiffre publié.

A. Ce que le bloc doit contenir

Raschka énumère les pièces nécessaires à la construction de l’architecture GPT : l’ossature GPT, la normalisation de couche, l’activation GELU, le réseau à propagation avant, les connexions de raccourci, le bloc de transformeur qui les assemble, et l’architecture finale. L’attention est le mécanisme à l’intérieur du bloc ; le reste est ce qui rend entraînable une pile profonde de ces blocs.

B. L’attention multi-têtes

Une seule opération d’attention produit une pondération sur les positions, exprimant une notion de pertinence. L’attention multi-têtes en exécute plusieurs en parallèle, chacune avec ses propres $W_q, W_k, W_v$, puis concatène et projette les résultats.

Les têtes ne reçoivent pas chacune toute la largeur. Dans GPT-2 small la dimension de plongement est 768 et il y a 12 têtes, chaque tête travaille donc en

$$d_{\text{head}} = \frac{768}{12} = 64$$

dimensions. Douze têtes de dimension 64 se concatènent pour redonner 768. Le coût est donc le même que celui d’une tête de dimension 768, tandis que le modèle gagne douze schémas de pertinence indépendants au lieu d’un - différentes têtes peuvent s’intéresser à différentes relations sans se disputer une pondération unique.

C. La normalisation de couche

Les piles profondes sont instables à entraîner lorsque l’échelle des activations dérive d’une couche à l’autre. La normalisation de couche remet chaque vecteur à moyenne nulle et variance unité :

$$\hat{x}_i = \frac{x_i - \mu}{\sqrt{\sigma^2 + \epsilon}}, \qquad \mu = \frac{1}{n}\sum_i x_i, \qquad \sigma^2 = \frac{1}{n}\sum_i (x_i - \mu)^2 ,$$

avec un petit $\epsilon$ qui prémunit contre la division par zéro. Des paramètres appris d’échelle et de décalage suivent, de sorte que la couche peut défaire la normalisation si cela s’avère utile.

Déroulé, sur un vecteur de dimension 8. Prenons

$$\mathbf{x} = \begin{bmatrix}2 & 4 & 4 & 4 & 5 & 5 & 7 & 9\end{bmatrix} .$$

La somme vaut $40$, donc $\mu = 40/8 = 5$. Les écarts au carré sont $9, 1, 1, 1, 0, 0, 4, 16$, de somme $32$, donc $\sigma^2 = 32/8 = 4$ et $\sigma = 2$. En soustrayant la moyenne et en divisant par l’écart type :

$$\hat{\mathbf{x}} = \begin{bmatrix}-1.5 & -0.5 & -0.5 & -0.5 & 0 & 0 & 1 & 2\end{bmatrix} .$$

Le résultat a une moyenne de $0$ et une variance de $1$, comme demandé.

Sur les caractéristiques, non sur le lot. Raschka trace explicitement le contraste avec la normalisation par lots : la batch norm normalise selon la dimension du lot, tandis que la layer norm normalise selon la dimension des caractéristiques. La distinction compte pour les modèles de langue, où les séquences d’un lot diffèrent en longueur et en contenu - la layer norm traite chaque position indépendamment et se moque donc du reste du lot.

Où placer la normalisation est en soi une décision de conception avec une histoire. Raschka note que le Post-LayerNorm, utilisé dans le transformeur originel, applique la normalisation après les sous-couches d’attention et de propagation avant, tandis que le Pre-LayerNorm, adopté dans GPT-2 et les LLM plus récents, l’applique avant - ce qui peut conduire à des dynamiques d’entraînement plus stables.

D. Les connexions de raccourci

Le cadrage de Raschka est direct : les connexions de raccourci - dites aussi connexions de saut ou résiduelles - furent proposées à l’origine pour les réseaux profonds de vision par ordinateur (précisément les réseaux résiduels) afin d’atténuer la disparition des gradients. L’opération est une addition : l’entrée d’une couche est ajoutée à sa sortie, créant un chemin alternatif qui contourne la couche.

$$\mathbf{y} = \mathbf{x} + F(\mathbf{x})$$

L’effet est mesurable, et Raschka le mesure. Dans un réseau à cinq couches il rapporte le gradient absolu moyen à chaque couche, avec et sans raccourcis :

Sans raccourcis, le gradient qui atteint la couche 1 est d’environ $0.0002$ - trois ordres de grandeur plus petit qu’à la couche 5, si bien que les premières couches n’apprennent presque pas. Avec raccourcis les gradients restent comparables de bout en bout. La raison est visible dans la dérivée : dériver $\mathbf{y} = \mathbf{x} + F(\mathbf{x})$ donne $1 + F'(\mathbf{x})$, et ce $1$ est un chemin le long duquel le gradient circule sans atténuation, si petit que devienne $F'$.

E. Le réseau à propagation avant

Après que l’attention a mélangé l’information entre positions, un réseau à propagation avant transforme chaque position indépendamment. Sa forme est distinctive : Raschka décrit les entrées se dilatant d’un facteur quatre, de 768 à 3 072 valeurs, une seconde couche recomprimant les 3 072 vers 768.

$$768 \;\xrightarrow{\;\text{expand}\;}\; 3072 \;\xrightarrow{\;\text{GELU}\;}\; 3072 \;\xrightarrow{\;\text{contract}\;}\; 768$$

L’activation entre les deux est GELU plutôt que la ReLU de Qu’est-ce qu’un réseau de neurones ?. Raschka les oppose en notant que la ReLU est une fonction linéaire par morceaux, tandis que GELU est lisse - elle a un gradient non nul pour les entrées négatives au lieu du zéro plat de la ReLU, ce qui évite le mode de défaillance des unités mortes.

Notez l’asymétrie de paramètres que cela crée : le réseau à propagation avant détient environ deux fois plus de paramètres que l’attention qu’il suit, ce qui surprend ceux qui pensent l’attention comme « le » transformeur.

F. Compter GPT-2 small

Raschka passe à l’échelle du plus petit GPT-2, 124 millions de paramètres, et ajoute une correction bibliographique utile : si le rapport original mentionnait 117 millions, ce chiffre fut corrigé par la suite. La table de configuration donne la famille :

avec vocab_size 50 257 et context_length 1 024.

Nous pouvons vérifier le chiffre phare. Par bloc, avec $d = 768$ :

• Attention - quatre projections ($W_q, W_k, W_v$, sortie), chacune $768\times768$ plus un biais : $4(768^2 + 768) = 2{,}362{,}368$.
• Propagation avant - $768 \times 3072 + 3072$ en dilatation, $3072 \times 768 + 768$ en contraction : $4{,}722{,}432$.
• Deux normalisations de couche - échelle et décalage, $768$ chacun : $4 \times 768 = 3{,}072$.

Soit $7{,}087{,}872$ par bloc, et $\times 12$ blocs donne $85{,}054{,}464$. Après le dernier bloc se trouve encore une normalisation de couche, la normalisation finale de la section G, avec sa propre échelle et son propre décalage : $2 \times 768 = 1{,}536$. En ajoutant les plongements de La tokenisation et les plongements - tokens $50{,}257 \times 768 = 38{,}597{,}376$ et positions $1{,}024 \times 768 = 786{,}432$ :

$$85{,}054{,}464 + 1{,}536 + 38{,}597{,}376 + 786{,}432 = 124{,}439{,}808 .$$

124,4 millions - le chiffre publié, et au paramètre près le décompte du point de contrôle GPT-2 small diffusé. La couche de sortie n’ajoute rien, car GPT-2 y réutilise les poids du plongement de tokens.

Où vivent réellement les paramètres. Les plongements pèsent 39,4 millions des 124 millions - près d’un tiers - et ce sont une table de consultation, non du calcul. Pendant ce temps les 12 blocs qui font tout le travail en détiennent 85 millions. Ce rapport se déplace nettement avec l’échelle : emb_dim et n_layers croissent tous deux dans les modèles plus grands, si bien que les paramètres des blocs croissent à peu près quadratiquement tandis que le plongement de tokens ne croît que linéairement.

G. Le bloc assemblé

En plaçant les pièces dans l’ordre Pre-LayerNorm, chaque bloc est fait de deux sous-couches, chacune normalisée d’abord et enveloppée dans un raccourci :

$$\mathbf{x} \leftarrow \mathbf{x} + \operatorname{MultiHeadAttention}(\operatorname{LayerNorm}(\mathbf{x}))$$ $$\mathbf{x} \leftarrow \mathbf{x} + \operatorname{FeedForward}(\operatorname{LayerNorm}(\mathbf{x}))$$

La forme ne change jamais : un bloc envoie un tenseur $(\text{batch},\ \text{séquence},\ 768)$ sur un autre exactement de même forme. Cette invariance est ce qui permet aux blocs de s’empiler - douze pour GPT-2 small, quarante-huit pour GPT-2 XL, sans autre changement structurel. Le modèle complet, ce sont les plongements, puis $N$ blocs identiques, puis une normalisation finale et une projection vers la taille du vocabulaire, donnant un score par token pour la position suivante.

Parce que l’attention interne est masquée causalement, la position $i$ ne peut s’intéresser qu’aux positions $\le i$ : une seule passe avant produit donc une prédiction du token suivant à chaque position à la fois - ce qui est exactement ce qui rend efficace l’objectif d’entraînement de l’article suivant.

À retenir

• L’attention multi-têtes répartit le plongement entre les têtes - $768/12 = 64$ par tête dans GPT-2 small - de sorte que plusieurs schémas de pertinence sont appris au coût d’une seule tête.
• La normalisation de couche remet chaque vecteur à moyenne nulle et variance unité selon la dimension des caractéristiques, contrairement à la dimension de lot de la batch norm.
• Le transformeur originel utilisait le Post-LayerNorm ; GPT-2 et les modèles ultérieurs utilisent le Pre-LayerNorm pour un entraînement plus stable.
• Les connexions de raccourci ajoutent l’entrée d’une couche à sa sortie ; la dérivée $1 + F'$ qui en résulte garde les gradients vivants - 0,0002 contre 0,22 à la couche 1 dans la mesure de Raschka.
• Le réseau à propagation avant dilate $768 \to 3072 \to 768$ et détient environ deux fois les paramètres de l’attention voisine.
• Le décompte des blocs, de la normalisation finale et des plongements donne 124 439 808 paramètres pour GPT-2 small, conforme aux 124M publiés (les 117M du rapport original ayant été corrigés depuis).
• Un bloc préserve la forme de son entrée, ce qui est précisément pourquoi l’architecture passe à l’échelle par empilement.

La suite

Nous avons une architecture de 124 millions de paramètres initialisés au hasard, qui ne prédit rien. La transformer en un modèle qui écrit un texte fluide, puis en un modèle qui suit des instructions, est le sujet de Le préentraînement et l’affinage.