Les modèles encodeur-décodeur récurrents font passer toute une séquence d'entrée par un unique vecteur de contexte de taille fixe, ce qui limite ce qu'ils peuvent mémoriser pour de longues entrées. L'attention supprime ce goulot d'étranglement en laissant le décodeur lire directement chaque état de l'encodeur, en pondérant chacun selon sa pertinence pour l'étape de sortie courante. Cette leçon construit le mécanisme depuis les scores d'alignement jusqu'à la vision requête-clé-valeur, qui est le socle que le Transformeur va généraliser.

$$\boxed{ c = h_T }$$

Chaque étape $i$ du décodeur produit son état $s_i$ et sa sortie à partir de cet unique vecteur $c$ et de la sortie précédente. Tout le sens de l'entrée, aussi longue soit-elle, doit être compressé dans un unique $h_T$ de taille fixe.

*Remarque :* il s'agit d'un véritable goulot d'étranglement de l'information. Pour une phrase courte, $h_T$ peut en contenir assez, mais à mesure que $T$ grandit les premiers jetons sont écrasés et la qualité de la traduction ou du résumé chute fortement sur les longues entrées.

La solution consiste à garder disponibles tous les états de l'encodeur $h_1, \dots, h_T$ et à laisser le décodeur décider, à chaque étape, lesquels lire.

Au lieu d'un unique vecteur de contexte partagé entre toutes les étapes, l'attention construit un nouveau vecteur de contexte $c_i$ pour chaque étape $i$ du décodeur. Elle procède en trois temps : scorer, normaliser, combiner.

Pour l'étape $i$ du décodeur d'état $s_i$, une fonction de score mesure à quel point cet état s'aligne avec chaque état de l'encodeur $h_j$ :

$$e_{i,j} = \operatorname{score}(s_i, h_j)$$

Un $e_{i,j}$ élevé signifie que la position $j$ de l'encodeur est pertinente pour produire la sortie $i$. Les scores forment un vecteur sur les $T$ positions d'entrée.

*Remarque :* $s_i$ est généralement l'état du décodeur juste avant d'émettre le jeton $i$, de sorte que le modèle choisit ce qu'il regarde en fonction de ce qu'il a produit jusqu'ici.

Les scores sont transformés en une distribution de probabilité sur les positions d'entrée par une softmax sur $j$ :

$$\boxed{ \alpha_{i,j} = \frac{\exp(e_{i,j})}{\sum_{k=1}^{T} \exp(e_{i,k})} }$$

Chaque $\alpha_{i,j} \in (0,1)$ et $\sum_j \alpha_{i,j} = 1$, donc les poids indiquent quelle part de l'attention du décodeur à l'étape $i$ va à la position d'entrée $j$.

Le vecteur de contexte pour l'étape $i$ est la moyenne pondérée des états de l'encodeur, en utilisant les poids d'attention :

$$\boxed{ c_i = \sum_{j=1}^{T} \alpha_{i,j}\, h_j }$$

Ce $c_i$ est recalculé à chaque étape du décodeur, de sorte que le modèle lit un mélange différent de l'entrée pour chaque jeton de sortie. Le décodeur combine ensuite $c_i$ avec son état $s_i$ pour prédire le jeton, et les poids d'alignement $\alpha_{i,j}$ peuvent se visualiser comme une matrice douce qui montre quels mots d'entrée chaque mot de sortie regarde.

Le score additif, dû à Bahdanau et ses co-auteurs, fait passer les deux états dans un petit réseau à une couche cachée avec des matrices apprises $W_1$ et $W_2$ et un vecteur appris $v$ :

$$\boxed{ e_{i,j} = v^{\top} \tanh\!\left( W_1 s_i + W_2 h_j \right) }$$

Il fonctionne même lorsque $s_i$ et $h_j$ ont des dimensions différentes, puisque $W_1$ et $W_2$ projettent les deux dans un espace commun avant le $\tanh$.

Le score multiplicatif, dû à Luong et ses co-auteurs, est un simple produit scalaire entre les deux états :

$$\boxed{ e_{i,j} = s_i^{\top} h_j }$$

Il n'a aucun paramètre supplémentaire dans sa forme la plus simple et est bien moins coûteux à calculer, puisqu'une matrice entière de scores est un unique produit matriciel. Une variante générale insère une matrice apprise $W$ sous la forme $s_i^{\top} W h_j$ pour gérer les dimensions non concordantes.

| Aspect | Additif (Bahdanau) | Multiplicatif (Luong) |

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

| Formule | $v^{\top}\tanh(W_1 s_i + W_2 h_j)$ | $s_i^{\top} h_j$ |

| Paramètres supplémentaires | $W_1$, $W_2$, $v$ | aucun (ou une matrice $W$) |

| Dimensions différentes | géré par projection | nécessite la variante $W$ |

| Coût | plus lent, petit réseau par paire | rapide, un produit matriciel |

| Idéal quand | petits modèles, dimensions mixtes | grands modèles, dimensions concordantes |

*Remarque :* le produit scalaire croît avec la dimension des états, donc à grande largeur sa variance devient grande et pousse la softmax vers des régions plates. Mettre le score à l'échelle par $1/\sqrt{d}$ corrige cela, et ce produit scalaire mis à l'échelle est exactement ce que le Transformeur va adopter.

L'attention admet une lecture plus nette qui abandonne le cadre encodeur-décodeur. Renommons les pièces : l'état qui regarde est une requête, et chaque chose qui peut être regardée fournit une clé (utilisée pour le scoring) et une valeur (utilisée dans la somme).

$$\boxed{ q = s_i, \quad k_j = h_j, \quad v_j = h_j }$$

Avec cette dénomination, le score compare la requête à chaque clé, la softmax transforme les scores en poids, et la sortie est la somme pondérée des valeurs :

$$\boxed{ \operatorname{Attention}(q, K, V) = \sum_{j} \operatorname{softmax}_j\!\left(\operatorname{score}(q, k_j)\right) v_j }$$

Dans l'attention seq2seq classique, la clé et la valeur sont le même état d'encodeur $h_j$, mais rien n'y oblige. Séparer les trois rôles est ce qui débloque l'étape suivante.

*Remarque :* dans cette leçon, la requête vient du décodeur tandis que les clés et les valeurs viennent de l'encodeur, de sorte que la requête porte son attention sur une séquence différente. Lorsque la requête, les clés et les valeurs viennent toutes de la même séquence, chaque jeton porte son attention sur ses propres voisins. C'est l'auto-attention, et l'empiler est l'idée entière derrière le Transformeur.

---