🧠 Comment fonctionnent les IA ?

Bienvenue dans le chapitre 8 ! Au chapitre 6, tu as découvert les Transformers et l'attention en général. Au chapitre 7, tu as vu comment le texte devient des vecteurs (embedding) et comment on obtient les probabilités à la fin (softmax). Ici, on ouvre la boîte noire de l'attention : après l'embedding, les vecteurs des mots « communiquent » entre eux grâce à des requêtes, des clés et des valeurs. C'est ce mécanisme, pas à pas, que nous allons détailler. Le bloc MLP qui suit l’attention dans chaque couche du Transformer est détaillé au chapitre 9.

Le Transformer reçoit du texte (tokens), les transforme en vecteurs (embedding), puis enchaîne un grand nombre de blocs. Chaque bloc contient d'abord un bloc d'attention (détaillé dans ce chapitre), puis un MLP (réseau à propagation avant). L'entrée de l'attention est la séquence d'embeddings E (un vecteur par token). La sortie est une nouvelle séquence d'embeddings affinés E' = E + ΔE, où ΔE est calculé par le mécanisme d'attention. Ces vecteurs enrichis passent ensuite dans le MLP, puis éventuellement dans d'autres blocs attention + MLP, et à la fin seul le dernier vecteur sert à la prédiction du token suivant (comme vu au chapitre 7).

Après l'embedding, chaque token est associé à un vecteur. Mais au tout début, ce vecteur ne dépend que du mot (et de sa position) : il ne « voit » pas encore le contexte. Or le sens d'un mot dépend des mots autour. Par exemple, le mot « taupe » n'a pas le même sens dans « une taupe creuse des galeries » (animal), « une mole de carbone » (unité en chimie) ou « il a une taupe sur la joue » (grain de beauté). Le vecteur initial de « taupe » serait le même dans les trois phrases ; c'est le bloc d'attention qui permet aux autres mots d'envoyer de l'information vers ce vecteur pour le faire évoluer vers la bonne « direction » dans l'espace (animal, chimie, ou dermatologie).

Autre exemple : le mot « tour ». Si il est précédé de « Eiffel », le modèle voudra que son vecteur pointe vers quelque chose qui évoque la tour Eiffel (Paris, fer, etc.). Si il est aussi précédé de « miniature », le vecteur doit encore évoluer pour ne plus être associé à « grand » et « haut ». Ce transfert d'information d'un token vers un autre peut se faire sur de longues distances et impliquer bien plus qu'un seul mot.

Enfin, souviens-toi qu'à la fin du Transformer, seul le dernier vecteur de la séquence est utilisé pour prédire le mot suivant. Si le texte est un long roman policier qui se termine par « Donc le meurtrier était… », ce dernier vecteur (associé au mot « était ») doit avoir été mis à jour par toute l'attention pour encoder toute l'information pertinente du contexte — personnages, indices, etc. — afin de prédire correctement la suite. L'attention est le mécanisme qui permet à ce dernier vecteur d'« absorber » le contexte.

Dans une tête d'attention, on utilise trois matrices apprises : W_Q (requêtes), W_K (clés) et W_V (valeurs). Pour l'instant on s'intéresse à Q et K.

À partir de chaque embedding E (un vecteur par token), on calcule une requête Q = W_Q × E et une clé K = W_K × E. Les requêtes et les clés vivent dans un espace de plus petite dimension que les embeddings. On peut imaginer la requête du mot à la position i comme une « question » (« quels mots sont pertinents pour mettre à jour mon sens ? ») et la clé du mot à la position j comme une « réponse » potentielle. Pour mesurer à quel point le mot j est pertinent pour mettre à jour le mot i, on calcule le produit scalaire entre la requête du mot i et la clé du mot j : Q_i · K_j. Plus ce nombre est grand, plus les deux vecteurs sont alignés et plus le mot j « répond » à la « question » du mot i.

On fait cela pour toutes les paires (i, j). On obtient une grille de scores : en ligne le « mot qui pose la question » (qui reçoit l'information), en colonne le « mot qui répond » (qui envoie l'information). Chaque case (i, j) = score de pertinence du mot j pour le mot i.

Détail technique : pour la stabilité numérique, on divise ces scores par √d_k (où d_k est la dimension de l'espace des requêtes et clés) avant d'appliquer le softmax.

La grille des scores Q·K contient des nombres qui peuvent être négatifs ou très grands. Pour s'en servir comme poids (combien de chaque valeur ajouter à chaque position), on veut que chaque colonne soit une distribution de probabilités : des nombres entre 0 et 1 dont la somme vaut 1. On applique donc la fonction softmax par colonne : pour la colonne du mot i (le mot qu'on met à jour), on prend les scores de tous les mots j (ceux qui peuvent envoyer de l'information), on calcule l'exponentielle de chaque score (après division par √d_k), puis on divise par la somme. On obtient le motif d'attention : une grille de poids.

En plus, à l'entraînement, le modèle prédit le mot suivant à chaque position. Pour la position i, il ne doit pas « tricher » en regardant les mots en position j > i. On applique donc un masquage : avant le softmax, on met à −∞ tous les scores où j > i (un token « futur » ne doit pas influencer un token « passé »). Après softmax, ces cases deviennent 0. La grille devient triangulaire (ou triangulaire inférieure selon la convention).

Limitation : la taille du motif d'attention est le carré du nombre de tokens (une ligne et une colonne par token). Le coût en calcul et en mémoire croît donc en N². C'est une des raisons pour lesquelles la longueur de contexte des grands modèles est limitée.

Une fois qu'on a le motif d'attention (les poids par colonne), il faut décider quoi ajouter à chaque embedding. C'est le rôle des valeurs. On calcule pour chaque token un vecteur V = W_V × E. Ce vecteur vit dans le même espace (ou un espace de même dimension) que les embeddings. Il répond à la question : « Si ce mot est pertinent pour en modifier un autre, quelle modification envoyer ? »

En pratique, la « matrice valeur » est souvent décomposée en deux matrices plus petites (réduction de dimension puis remontée), pour garder un nombre de paramètres du même ordre que pour Q et K, tout en produisant des vecteurs utilisables pour mettre à jour les embeddings.

Pour la position i (le mot qu'on met à jour), on fait une combinaison linéaire de tous les vecteurs V_j, pondérée par les poids du motif d'attention sur la colonne i : ΔE_i = Σ_j (poids_{j,i} × V_j). Puis le nouvel embedding est E'_i = E_i + ΔE_i. On fait cela pour chaque position ; on obtient ainsi la séquence complète d'embeddings affinés E'.

Ce que nous avons décrit — requêtes, clés, valeurs, scores, softmax, combinaison des V — correspond à une seule tête d'attention. En réalité, un bloc d'attention en contient plusieurs (par exemple 96 dans GPT-3). Chaque tête a ses propres matrices W_Q, W_K, W_V, donc ses propres requêtes, clés et valeurs, et produit son propre motif d'attention et sa propre séquence de mises à jour ΔE. Les ΔE de toutes les têtes sont ensuite additionnés (ou concaténés puis projetés par une matrice de sortie, selon les implémentations) pour obtenir la mise à jour finale ajoutée à E. Ainsi, chaque tête peut apprendre un type de relation différent (par exemple une tête pour les accords adjectif-nom, une autre pour les références à des entités lointaines, etc.).

L'ordre de grandeur des paramètres : pour une tête, on a W_Q, W_K, et les deux matrices qui forment W_V (réduction puis remontée), soit environ 6 millions de paramètres pour une tête dans un modèle de la taille de GPT-3. Avec 96 têtes par bloc et 96 blocs, les paramètres d'attention représentent environ un tiers du total du modèle (environ 58 milliards pour l'attention dans GPT-3).

Tu as vu comment une tête d'attention fonctionne : les embeddings E sont transformés en requêtes Q, clés K et valeurs V. Les produits scalaires Q·K donnent des scores de pertinence ; le softmax (par colonne, avec éventuel masquage) produit un motif de poids ; la combinaison des valeurs V pondérée par ce motif donne la mise à jour ΔE ; et E' = E + ΔE. Les multi-têtes permettent d'avoir plusieurs « types » d'attention en parallèle et d'additionner leurs effets.

Une dernière raison du succès des Transformers : le calcul de l'attention est très parallélisable. Tous les produits scalaires, tous les softmax, toutes les combinaisons peuvent être effectués en même temps sur un GPU. Comme l'augmentation de la taille des modèles (scale) a souvent conduit à de grandes améliorations de performance, une architecture qui se prête bien au calcul massivement parallèle a un avantage décisif. L'attention n'est pas seulement puissante pour le sens — elle est aussi adaptée à l'échelle.