## Anatomie du Bloc Attention

L'attention permet à chaque mot de demander : "quels autres mots m'aident à comprendre mon rôle dans cette phrase ?" C'est le cœur du Transformer.

::: {.callout-note collapse="true"}
## 🔍 Lecture technique
Le **bloc d'attention** est l'unité de calcul fondamentale du Transformer. Contrairement aux convolutions qui capturent les corrélations locales, l'attention permet à chaque token d'interagir directement avec tous les autres tokens de la séquence — quel que soit leur éloignement. C'est ce mécanisme de **connectivité globale** qui distingue fondamentalement les Transformers des RNNs et CNNs [@June2023; @KamarainenND].
:::

::: {.card .card-window .mb-4}

:::: {.card-header}
🧱 Architecture Globale d'un Bloc Transformer (Encodeur)
::::

:::: {.card-body}
::::: {#plot-transformer-block .plot-wrapper}
:::::
::::

:::

```{ojs}
//| echo: false
import { initTransformerBlock } from "../../assets/js/simulations/attention.js"
_block_flow = initTransformerBlock("#plot-transformer-block", invalidation)
```

::: {.card .card-window .mb-4}

:::: {.card-header}
🕸️ Flux de Calcul de l'Attention (Q, K, V)
::::

:::: {.card-body}
::::: {#plot-attention-flow .plot-wrapper}
:::::
::::

:::

```{ojs}
//| echo: false
import { initAttentionFlow } from "../../assets/js/simulations/attention.js"
_attn_flow = initAttentionFlow("#plot-attention-flow", invalidation)
```

### La Triade Q, K, V

Q, K et V ressemblent à un système de recherche : la Query pose une question, la Key indique ce que chaque token peut offrir, et la Value contient l'information à récupérer.

::: {.callout-note collapse="true"}
## 🔢 Projections Q, K, V
Pour chaque token $i$ dans la séquence, l'attention compute trois vecteurs dérivés par projection linéaire de l'embedding $\mathbf{x}_i \in \mathbb{R}^{d_{\text{model}}}$ [@June2023] :

$$\mathbf{q}_i = \mathbf{W}_Q \mathbf{x}_i, \quad \mathbf{k}_i = \mathbf{W}_K \mathbf{x}_i, \quad \mathbf{v}_i = \mathbf{W}_V \mathbf{x}_i$$ ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations))

* **$\mathbf{x}_i \in \mathbb{R}^{d_{\text{model}}}$** : le vecteur d'embedding du $i$-ème token de la séquence.
* **$\mathbf{W}_Q, \mathbf{W}_K, \mathbf{W}_V$** : les matrices de projection linéaire apprises pour les requêtes, clés et valeurs.
* **Query $\mathbf{q}_i$** : La "requête" du token $i$ — ce qu'il cherche dans le contexte.
* **Key $\mathbf{k}_j$** : La "signature" du token $j$ — ce qu'il offre comme information.
* **Value $\mathbf{v}_j$** : Le contenu informationnel du token $j$.
:::

### Le Scaled Dot-Product Attention

L'attention compare les requêtes et les clés : plus elles se ressemblent, plus le token correspondant est écouté. Ensuite, le modèle fait une moyenne pondérée des valeurs utiles.

::: {.callout-note collapse="true"}
## 🔢 Formule d'attention
Le score d'attention entre token $i$ (position de requête) et token $j$ (position de clé) est le produit scalaire normalisé [@KamarainenND] :

$$a_{ij} = \frac{\mathbf{q}_i \cdot \mathbf{k}_j}{\sqrt{d_k}}$$

La normalisation par $\sqrt{d_k}$ (dimension des clés) est cruciale : sans elle, les produits scalaires croissent en $O(d_k)$ en magnitude, poussant le Softmax dans ses zones de saturation à gradient quasi-nul. Après softmax, on obtient les poids d'attention $\alpha_{ij} = \text{softmax}(a_{ij})$, et la sortie est l'agrégation pondérée des valeurs :

$$\text{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{softmax}\!\left(\frac{\mathbf{Q}\mathbf{K}^T}{\sqrt{d_k}}\right) \mathbf{V}$$ ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations))

* **$\mathbf{Q}, \mathbf{K}, \mathbf{V}$** : matrices regroupant les vecteurs requêtes, clés et valeurs de toute la séquence.
* **$\mathbf{K}^T$** : transposée de la matrice des clés (indiquant la transposition par l'exposant $T$).
* **$\text{softmax}(\cdot)$** : fonction d'activation normalisant les scores en probabilités (les poids d'attention).
* **$\sqrt{d_k}$** : facteur d'échelle, racine carrée de la dimension des clés.
:::

::: {.card .card-window .mb-4}

:::: {.card-header}
🔍 Carte d'Attention
::::

```{ojs}
//| echo: false
attn_sentence = [
  { id: 0, word: "Le"     },
  { id: 1, word: "féroce" },
  { id: 2, word: "chien"  },
  { id: 3, word: "a"      },
  { id: 4, word: "mordu"  },
  { id: 5, word: "l'"     },
  { id: 6, word: "homme"  }
]

attn_matrix = [
  [0.80, 0.15, 0.05, 0.00, 0.00, 0.00, 0.00],
  [0.10, 0.60, 0.30, 0.00, 0.00, 0.00, 0.00],
  [0.05, 0.25, 0.50, 0.05, 0.15, 0.00, 0.00],
  [0.00, 0.00, 0.10, 0.40, 0.50, 0.00, 0.00],
  [0.00, 0.00, 0.35, 0.05, 0.20, 0.05, 0.35],
  [0.00, 0.00, 0.00, 0.00, 0.00, 0.70, 0.30],
  [0.00, 0.00, 0.05, 0.00, 0.25, 0.10, 0.60]
]

mutable attn_activeQ = 4
```

```{ojs}
//| echo: false
import { renderSelfAttention } from "../../assets/js/simulations/attention.js"
renderSelfAttention(d3, { tokens: attn_sentence, matrix: attn_matrix, activeQuery: attn_activeQ, onSelectQuery: (index) => { mutable attn_activeQ = index; } })
```

:::

### Sous-Espaces Parallèles

Une seule tête d'attention ne suffit pas toujours. Plusieurs têtes permettent au modèle de regarder la phrase sous plusieurs angles : grammaire, référence, thème, relation longue distance.

::: {.callout-note collapse="true"}
## 🔢 Formule multi-tête
Plutôt qu'une seule attention globale, l'architecture Transformer utilise $H$ têtes d'attention parallèles, chacune opérant dans un sous-espace de dimension $d_k = d_{\text{model}} / H$ [@KamarainenND] :

$$\text{MultiHead}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{Concat}(\text{head}_1, \ldots, \text{head}_H) \mathbf{W}_O$$ ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations))

* **$H$** : nombre de têtes d'attention indépendantes travaillant en parallèle.
* **$\text{Concat}(\cdot)$** : opération de concaténation des sorties de toutes les têtes.
* **$\mathbf{W}_O$** : matrice de projection de sortie recombinante.

Chaque tête apprend à se focaliser sur un type différent de dépendance : certaines têtes capturent la syntaxe (sujet-verbe), d'autres la coréférence (pronom-antécédent), d'autres encore les relations sémantiques thématiques. La concaténation des sorties puis la projection $\mathbf{W}_O$ recombinent ces représentations parallèles.
:::

### Stabilisation du Bloc

Un bloc Transformer ne contient pas seulement l'attention. Il ajoute aussi des raccourcis, de la normalisation et un petit réseau MLP pour stabiliser et enrichir les représentations.

::: {.callout-note collapse="true"}
## 🔍 Composants de stabilisation
Autour du bloc d'attention, trois composants stabilisent le flux d'information dans les réseaux profonds [@KamarainenND] :

**Connexions Résiduelles :**

$$\mathbf{x}' = \mathbf{x} + \text{Attention}(\mathbf{x})$$

Les connexions de saut (*skip connections*) préservent l'identité du signal original, empêchant la dégradation du gradient dans les réseaux profonds (problème de vanishing gradient vu au chapitre 2). En termes de représentation, elles garantissent que chaque couche *ajoute* de l'information plutôt que de la *transformer* entièrement.

**Normalisation :**

Deux variantes coexistent : LayerNorm (BERT, GPT-2) normalise sur les dimensions du modèle ; RMSNorm (LLaMA) normalise uniquement par la racine quadratique de la moyenne des carrés, sans centrage. RMSNorm est 15-20% plus rapide tout en préservant la stabilité.

**MLP (Feed-Forward Network) :**

Après l'attention (qui capture les *relations* entre tokens), un MLP effectue un **raffinement des caractéristiques** dans l'espace latent de chaque token indépendamment. La structure standard est une expansion-contraction :

$$\text{FFN}(\mathbf{x}) = \text{GELU}(\mathbf{x}\mathbf{W}_1 + \mathbf{b}_1)\mathbf{W}_2 + \mathbf{b}_2$$ ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations))

* **$\text{GELU}(\cdot)$** : fonction d'activation non linéaire.
* **$\mathbf{W}_1, \mathbf{b}_1$** : poids et biais de la première couche linéaire (expansion de dimension).
* **$\mathbf{W}_2, \mathbf{b}_2$** : poids et biais de la seconde couche linéaire (contraction de dimension).

avec $d_{\text{ff}} = 4 d_{\text{model}}$ typiquement. Le MLP est responsable de 2/3 des paramètres du Transformer — c'est là que réside la "mémoire factuelle" du modèle.
:::

### Optimisation Matérielle

À grande échelle, comprendre l'attention ne suffit pas : il faut aussi l'exécuter vite. Certaines optimisations séparent la lecture des embeddings et le calcul pour éviter que le matériel attende la mémoire.

::: {.callout-note collapse="true"}
## 🔍 Détails matériel/compilateur
La précision mathématique de l'attention ne suffit pas — l'efficacité d'exécution conditionne la scalabilité. Sur les architectures GPU standard, les opérations de lookup d'embeddings (décrites en section précédente) constituent un goulot d'étranglement que le compilateur **Ember** résout via l'architecture **DAE** (*Decoupled Access-Execute*) [@Siracusa2025] :

**Le TMU (Tensor Marshaling Unit) :**

Une unité physiquement séparée du cœur de calcul, dédiée exclusivement à la traversée des structures de données et au regroupement (*marshaling*) des embeddings. Pendant que le TMU prépare les vecteurs, le cœur de calcul exécute l'attention sur les données déjà streamées.

**Optimisations du Compilateur Ember :**

Ember utilise une représentation intermédiaire SLC IR (*Structured Lookup-Compute*) pour trois optimisations clés [@Siracusa2025] :

1. **Vectorisation (Arm SVE)** : Utilisation automatique d'unités vectorielles larges avec gestion intelligente des masques.
2. **Buffering d'Embedding** : Un jeton `ee` (*end-of-embedding*) signale la fin d'un vecteur, permettant au CPU de générer les positions positionnelles localement sans dépendre du TMU.
3. **Alignement de Queue** : Padding des scalaires pour maintenir l'alignement des lignes de cache et éviter les chargements vectoriels désalignés.

**Résultat :** Un gain moyen de **5,8×** sur les opérations d'embedding, avec une efficacité énergétique 4× supérieure aux GPUs traditionnels sur ces opérations spécifiques [@Siracusa2025]. Ce co-design matériel-logiciel transforme une opération limitée par la latence mémoire en un flux continu haute performance.
:::
