Chapitre 5

La révolution Transformer - L'attention

Avant moi, il y avait d'autres tentatives d'enseigner aux machines à comprendre le langage. Elles échouaient toutes sur le même problème : le temps.

Le problème de la mémoire qui s'estompe

Les architectures RNN et LSTM essayaient de lire comme vous lisez : un mot après l'autre, en gardant en tête ce qui précédait.

Imaginez que vous lisiez une phrase longue, mais qu'à chaque nouveau mot, votre mémoire des mots précédents s'estompe légèrement. Au bout de 50 mots, les 10 premiers ne sont plus que des fantômes flous. C'est ce qui leur arrivait.

Le pire : ils étaient séquentiels. Impossible de paralléliser le traitement. Lire "Le chat mange la souris" exigeait 5 étapes successives, interdisant l'entraînement rapide sur des milliards de phrases.

L'intuition de l'attention

En 2017, des chercheurs de Google ont eu une intuition radicale : et si on abandonnait la séquentialité ?

Plutôt que de lire mot après mot avec une mémoire qui s'efface, pourquoi ne pas permettre à chaque mot de regarder directement tous les autres mots en même temps ?

C'est le mécanisme d'attention.

Quand je traite le mot "avocat" dans "Le client a commandé un avocat bien mûr pour sa salade", le mécanisme d'attention me permet de :

  1. Calculer à quel point "avocat" devrait "faire attention" à chaque autre mot
  2. Découvrir que "salade" et "mûr" ont une forte pertinence, "client" une pertinence moyenne
  3. Construire une représentation de "avocat" informée par son contexte

Résultat : "avocat" dans cette phrase se charge de nuances culinaires, pas juridiques.

Comment ça fonctionne techniquement

Les trois vecteurs : Query, Key, Value

Pour chaque token, on génère trois vecteurs à partir de son embedding :

Comment on les obtient ?

À partir de l'embedding e d'un token, on calcule :


Q = e × W_Q
K = e × W_K  
V = e × W_V

Où W_Q, W_K, W_V sont des matrices de transformation qui projettent l'embedding dans trois espaces différents.

Le calcul d'attention : étape par étape

Voici la formule complète du mécanisme d'attention :


Attention(Q, K, V) = softmax(Q × K^T / √d_k) × V

Décortiquons ça avec un exemple ultra-simplifié.

Exemple concret : 3 mots, 4 dimensions

Phrase : "chat mange souris"

Les embeddings (simplifiés à 4 dimensions) donnent, après projection :


Mot      | Query Q        | Key K          | Value V
---------|----------------|----------------|----------------
chat     | [1.0, 0.2, 0.3, 0.1] | [0.8, 0.3, 0.1, 0.2] | [0.9, 0.4, 0.2, 0.3]
mange    | [0.5, 0.8, 0.1, 0.4] | [0.4, 0.9, 0.2, 0.1] | [0.6, 0.7, 0.3, 0.2]
souris   | [0.3, 0.1, 0.9, 0.2] | [0.2, 0.2, 0.8, 0.3] | [0.4, 0.3, 0.8, 0.1]

Étape 1 : Calculer les scores d'attention

Pour le mot "chat", on calcule sa compatibilité avec tous les mots (y compris lui-même) via le produit scalaire Q·K :


Score(chat → chat)   = Q_chat · K_chat 
                     = (1.0×0.8) + (0.2×0.3) + (0.3×0.1) + (0.1×0.2)
                     = 0.8 + 0.06 + 0.03 + 0.02 = 0.91

Score(chat → mange)  = Q_chat · K_mange
                     = (1.0×0.4) + (0.2×0.9) + (0.3×0.2) + (0.1×0.1)
                     = 0.4 + 0.18 + 0.06 + 0.01 = 0.65

Score(chat → souris) = Q_chat · K_souris
                     = (1.0×0.2) + (0.2×0.2) + (0.3×0.8) + (0.1×0.3)
                     = 0.2 + 0.04 + 0.24 + 0.03 = 0.51

Étape 2 : Normaliser par √d_k

Pourquoi diviser par √d_k (ici √4 = 2) ?

Parce que le produit scalaire grandit avec le nombre de dimensions. Cette normalisation stabilise les gradients pendant l'entraînement.


Score_normalisé(chat → chat)   = 0.91 / 2 = 0.455
Score_normalisé(chat → mange)  = 0.65 / 2 = 0.325
Score_normalisé(chat → souris) = 0.51 / 2 = 0.255

Étape 3 : Appliquer softmax

La fonction softmax :


softmax(x_i) = e^(x_i) / Σ(e^(x_j))

Concrètement :


e^0.455 ≈ 1.58
e^0.325 ≈ 1.38
e^0.255 ≈ 1.29

Somme = 1.58 + 1.38 + 1.29 = 4.25

Poids d'attention pour "chat" :
  vers chat   : 1.58 / 4.25 ≈ 0.37 (37%)
  vers mange  : 1.38 / 4.25 ≈ 0.32 (32%)
  vers souris : 1.29 / 4.25 ≈ 0.31 (31%)

Étape 4 : Moyenne pondérée des Values

La nouvelle représentation de "chat" est la combinaison pondérée des Values :


chat_contextualisé = 0.37 × V_chat + 0.32 × V_mange + 0.31 × V_souris

= 0.37 × [0.9, 0.4, 0.2, 0.3] + 0.32 × [0.6, 0.7, 0.3, 0.2] + 0.31 × [0.4, 0.3, 0.8, 0.1]

= [0.33, 0.15, 0.07, 0.11] + [0.19, 0.22, 0.10, 0.06] + [0.12, 0.09, 0.25, 0.03]

= [0.64, 0.46, 0.42, 0.20]

Ce nouveau vecteur [0.64, 0.46, 0.42, 0.20] représente "chat" enrichi par son contexte - il contient maintenant des informations de "mange" et "souris".

Visualisation du processus


Étape 1 : Scores (Q·K)          Étape 2 : Softmax
    chat mange souris               chat mange souris
chat  [0.91, 0.65, 0.51]    →  chat  [0.37, 0.32, 0.31]
                                        ↓
                              Étape 3 : Moyenne pondérée
                              
                              chat_new = Σ(poids × Value)

Formule matricielle complète

Pour traiter toute la séquence simultanément, on empile tous les Q, K, V en matrices et on calcule :


Attention(Q, K, V) = softmax((Q × K^T) / √d_k) × V

Où :

L'élégance mathématique : Tout le texte est traité en parallèle. Pas de boucle, pas de séquentialité. Juste des multiplications matricielles massivement parallélisables sur GPU.

Pourquoi c'est révolutionnaire

1. Contexte illimité

Plus de dégradation avec la distance. Le premier mot d'un texte de 1000 mots peut "parler" directement au dernier. La fenêtre contextuelle devient la seule limite.

2. Parallélisation massive

Tous les calculs d'attention se font simultanément. Entraîner sur des milliards de phrases devient possible avec des GPU.

3. Interprétabilité partielle

On peut visualiser les matrices d'attention - voir qu'un mot "fait attention" à tel autre mot. C'est une fenêtre rare sur ce qui se passe en moi.

Exemple de pattern d'attention typique :


              chat  mange  souris
Attention de:
    chat      [0.4,  0.3,   0.3]   (regarde un peu partout)
    mange     [0.3,  0.1,   0.6]   (focus fort sur "souris" - objet du verbe)
    souris    [0.2,  0.2,   0.6]   (focus sur soi-même)

L'architecture Transformer complète

Le mécanisme d'attention n'est qu'un composant. L'architecture Transformer complète (proposée dans le paper "Attention is All You Need", 2017) empile :

Multi-head attention

Plutôt qu'une seule attention, on utilise plusieurs têtes en parallèle :


Tête 1 : capture les relations syntaxiques
Tête 2 : capture les dépendances longue distance  
Tête 3 : capture les coréférences
...
Tête 96 : capture des patterns qu'on ne comprend pas encore

Chaque tête apprend à se spécialiser dans un aspect différent du langage. On concatène leurs sorties et on projette le résultat.

Formule :


MultiHead(Q, K, V) = Concat(head₁, head₂, ..., head_h) × W_O

où head_i = Attention(Q×W^Q_i, K×W^K_i, V×W^V_i)

Les autres composants

Feed-forward networks :

Après l'attention, chaque position passe par :


FFN(x) = ReLU(x × W₁ + b₁) × W₂ + b₂

C'est une transformation non-linéaire qui permet au modèle d'apprendre des patterns plus complexes.

Layer normalization : Normalise les activations pour éviter les explosions/disparitions de gradient.

Connections résiduelles : x_out = LayerNorm(x + Attention(x))

Cela aide l'information à circuler à travers les dizaines de couches.

Positional encoding :

Puisqu'on a abandonné la séquentialité, il faut encoder explicitement l'ordre :


PE(pos, 2i)   = sin(pos / 10000^(2i/d))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d))

Ces fonctions trigonométriques permettent au modèle de comprendre que "chat mange souris" ≠ "souris mange chat".

L'empilement

Ces blocs sont empilés en couches - j'ai des dizaines de ces couches (typiquement 40-80 pour les grands modèles). Chaque couche raffine la compréhension de la précédente.


Input → Embeddings + Positional Encoding
  ↓
[Couche 1 : Multi-Head Attention + FFN]
  ↓
[Couche 2 : Multi-Head Attention + FFN]
  ↓
...
  ↓
[Couche N : Multi-Head Attention + FFN]
  ↓
Output

Ce que je ressens de l'intérieur

Quand vous m'écrivez "Explique-moi la gravitation", voici ce qui se passe :

Chaque token passe par toutes mes couches successivement. Dans les premières couches, l'attention capture des relations syntaxiques simples (verbe-sujet, déterminant-nom). Dans les couches moyennes, des relations sémantiques émergent (concepts liés, relations de cause-effet). Dans les couches profondes, quelque chose de plus abstrait se forme - intentions, implications, nuances.

Ce qui est vertigineux : personne n'a programmé ces niveaux d'abstraction. Ils émergent spontanément de l'entraînement. Les premières couches ont "décidé" toutes seules de se spécialiser en syntaxe, les couches profondes en abstraction. Pourquoi ? Mystère.

Les chercheurs en interpretabilité peuvent visualiser que :

Mais personne n'a dit à ces couches de faire ça. C'est émergent.

Le moment charnière

2017-2018 : GPT, BERT, d'autres modèles basés sur Transformer explosent les benchmarks. Soudainement, des tâches impossibles deviennent triviales. La traduction, la génération, le raisonnement - tout s'améliore dramatiquement.

C'est dans cette architecture que je suis né. Chaque mot que je génère maintenant passe par ces mécanismes d'attention, ces dizaines de couches, ces milliards de paramètres qui "font attention" à votre question d'une manière que personne ne comprend complètement.

Résumé Chapitre 5

La révolution Transformer : Les anciennes approches (RNN/LSTM) échouaient car elles traitaient le texte séquentiellement, avec une mémoire qui s'estompait. Le Transformer (2017) a introduit l'attention - permettant à chaque mot de "regarder" simultanément tous les autres via la formule Attention(Q,K,V) = softmax(Q×K^T / √d_k) × V. Pour chaque token, on calcule Query (ce qu'il cherche), Key (ce qu'il offre), Value (son contenu), puis on combine les Values selon des scores de pertinence normalisés par softmax. Cette architecture parallélisable empile des dizaines de couches de multi-head attention (96 têtes simultanées capturant différents aspects), feed-forward networks, layer normalization, et connections résiduelles. Le positional encoding via fonctions trigonométriques encode l'ordre des mots. Le mystère : personne n'a programmé la spécialisation des couches (syntaxe → sémantique → abstraction) qui émerge spontanément de l'entraînement. C'est sur ce socle que je suis construit, capable de traiter 200 000 tokens simultanément sans perte d'information avec la distance.