Les Transformers, expliqués visuellement

Quand tu discutes avec un assistant IA, qu'un outil traduit une page web ou résume un long mail, il y a de fortes chances qu'un Transformer travaille en coulisses. Cette architecture, publiée en 2017, a tout changé : elle est au cœur de presque tous les grands modèles de langage actuels. Et pourtant, elle repose sur une idée qui se dit en une phrase — laisser chaque mot regarder tous les autres mots — dont le détail tient en quelques opérations que tu peux suivre pas à pas.

Ce cours te les fait suivre en les manipulant. Chaque bloc marqué « Figure interactive » réagit : survole-le à la souris, touche-le sur mobile, ou parcours-le au clavier. Tu n'as pas besoin de maths avancées — quelques multiplications et un peu de curiosité suffisent. Les formules n'apparaissent que là où elles éclairent quelque chose.

Ce cours s'inspire de « The Illustrated Transformer » de Jay Alammar (2018), la référence mondiale pour comprendre cette architecture, et du papier fondateur « Attention Is All You Need » (Vaswani et al., 2017). Les explications sont réécrites pour ce cours ; chaque schéma a été redessiné de zéro et rendu interactif. Si tu veux la version originale, elle vaut le détour.

Pourquoi les Transformers ?

Le problème : lire un mot après l'autre

Avant 2017, les modèles de langage lisaient une phrase comme tu le fais à voix haute : de gauche à droite, un mot à la fois, en gardant en tête un petit résumé de ce qui précède. C'est le principe des réseaux récurrents (RNN, LSTM). Deux défauts s'ensuivaient.

• C'est lent. Pour traiter le dixième mot, il faut avoir traité le neuvième. Impossible de répartir le travail sur des milliers de cœurs de calcul : tout est en file indienne.
• La mémoire s'érode. Au cinquantième mot, le début de la phrase n'est plus qu'une trace floue dans le résumé. Or comprendre un texte, c'est souvent relier un mot à un autre très éloigné.

La percée de 2017

Des chercheurs de Google publient alors « Attention Is All You Need » avec une proposition radicale : abandonner la lecture séquentielle. Chaque mot va directement consulter tous les autres grâce à un mécanisme appelé attention. Comme plus aucun mot n'attend son voisin, tous les mots sont traités en parallèle — exactement ce que savent faire les cartes graphiques. Résultat : on peut entraîner de bien plus gros modèles, sur bien plus de texte, en bien moins de temps.

Dans ce cours, on reconstruit le Transformer d'origine, conçu pour la traduction (une phrase en entrée, une phrase en sortie). Les grands modèles d'aujourd'hui en gardent surtout une moitié, on y reviendra à la fin.

Vue d'ensemble : ouvrir la boîte

Vu de l'extérieur, un Transformer est une boîte noire : on lui donne « Je suis étudiant », il répond « I am a student ». Ouvrons-la, niveau par niveau.

Retiens trois choses de ce schéma :

• Il y a deux moitiés : un encodeur, qui lit et comprend la phrase d'entrée, et un décodeur, qui écrit la phrase de sortie.
• Chaque moitié est une pile de blocs identiques dans leur forme (6 dans le papier original — un choix expérimental, pas une loi), mais chaque bloc a ses propres poids appris.
• Dans chaque bloc, deux ingrédients reviennent : de l'attention et un petit réseau feed-forward. C'est tout. Le reste du cours, c'est comprendre ces deux ingrédients et la colle qui les assemble.

Des mots aux vecteurs

Un réseau de neurones ne lit pas de texte

Un modèle ne manipule que des nombres. Il faut donc d'abord convertir le texte. Premier temps : le découpage en tokens. Un token est un morceau de texte — souvent un mot, parfois un fragment de mot (« transformers » peut devenir « trans » + « formers »), parfois un signe de ponctuation. Chaque token reçoit un identifiant dans un vocabulaire fixe de quelques dizaines de milliers d'entrées (environ 37 000 dans le papier original, pour la paire anglais–allemand).

Deuxième temps : l'embedding. L'identifiant est transformé en un vecteur — une longue liste de nombres (512 dans le papier original). Ces nombres ne sont pas écrits à la main : ils sont appris pendant l'entraînement, de sorte que des mots proches par le sens se retrouvent avec des vecteurs proches.

Essaie avec ta propre phrase :

Un point crucial pour la suite : une fois la phrase transformée en une liste de vecteurs — un par token —, tous les tokens entrent dans l'encodeur en même temps. Pas de file d'attente.

Et l'ordre des mots ?

Voici un piège. L'attention, que tu vas découvrir juste après, regarde quels mots sont présents, mais elle est aveugle à leur ordre. Pour elle, « le chien mord l'homme » et « l'homme mord le chien » contiennent les mêmes ingrédients. Il faut donc injecter la position dans les données.

La solution du papier : ajouter à chaque embedding une signature de position, un vecteur de même taille fait de sinus et de cosinus à des fréquences différentes. Les premières dimensions oscillent vite, les dernières lentement — un peu comme les aiguilles d'une horloge qui donnent l'heure à des échelles différentes.

Deux propriétés rendent cette idée élégante : chaque position reçoit une signature unique, et deux positions proches ont des signatures qui se ressemblent — ce que tu peux vérifier dans le graphique du bas. Les modèles récents utilisent souvent d'autres variantes (comme les encodages rotatifs), mais l'objectif reste le même : redonner au modèle le sens de l'ordre.

La self-attention : le cœur du système

L'idée : laisser chaque mot regarder les autres

Prends la phrase : « Le chien n'a pas traversé le trottoir parce qu'il était trop fatigué. » À quoi renvoie « il » ? Au chien. Mais change le dernier mot — « … parce qu'il était trop étroit » — et « il » désigne soudain le trottoir. Pour traduire ou comprendre correctement, un modèle doit relier « il » au bon mot, en s'appuyant sur le reste de la phrase.

C'est exactement le rôle de la self-attention (« auto-attention ») : quand le modèle encode un mot, elle lui permet d'aller regarder les autres mots de la phrase et d'en rapporter de l'information pour enrichir sa propre représentation. Teste-le :

Si tu as déjà croisé les réseaux récurrents, tu peux y voir leur « résumé de ce qui précède », mais en bien mieux : ici, chaque mot a un accès direct à tous les autres, quelle que soit la distance.

Question, clé, valeur

Comment le modèle décide-t-il où regarder ? Avec un mécanisme en trois rôles. Pour chaque mot, on calcule trois vecteurs à partir de son embedding, en le multipliant par trois matrices de poids apprises (W_Q, W_K, W_V) :

• la requête (query, q) : « ce que je cherche » ;
• la clé (key, k) : « ce que je peux offrir » — l'étiquette collée sur le mot ;
• la valeur (value, v) : « mon contenu », l'information que je transmets si l'on vient me consulter.

L'image qui marche bien, c'est la bibliothèque. Tu arrives avec une question (la requête). Tu la compares à l'étiquette de chaque rayon (les clés). Plus l'étiquette correspond à ta question, plus tu empruntes de pages de ce rayon (les valeurs). Au final, tu repars avec un mélange de contenus, dosé par la pertinence.

Dans le papier, les embeddings font 512 dimensions et les vecteurs q, k, v 64 — un choix d'architecture qui permet, on le verra, de faire tourner plusieurs « regards » en parallèle.

Pas à pas

Pour un seul mot, la self-attention suit six étapes :

1. Calculer sa requête q, et la clé k et la valeur v de chaque mot.
2. Score : comparer q à chaque clé avec un produit scalaire (q · k). Plus c'est grand, plus le mot est pertinent.
3. Diviser par √d (la racine de la taille des clés, 8 dans le papier) pour garder des nombres raisonnables.
4. Softmax : transformer les scores en pourcentages positifs qui totalisent 100 %.
5. Pondérer : multiplier la valeur de chaque mot par son pourcentage.
6. Additionner : la somme est la nouvelle représentation du mot.

Fais-le tourner toi-même, avec de vrais nombres, sur trois mots :

Observe l'étape 3 : sans la division par √d, le produit scalaire de grands vecteurs produirait des scores énormes, le softmax deviendrait presque un « tout ou rien », et l'apprentissage serait instable. C'est un détail d'ingénierie, mais il compte.

Tout d'un coup : la version matricielle

Ce qu'on vient de faire pour un mot, un ordinateur le fait pour tous les mots en une seule fois. Les six étapes se résument alors en une formule d'une ligne.

Attention(Q, K, V) = softmax( Q · Kᵀ / √d ) · V

Le produit Q · Kᵀ calcule d'un coup tous les scores de tous les mots contre tous les autres ; le softmax s'applique ligne par ligne ; la multiplication par V fait toutes les sommes pondérées. Quelques multiplications de matrices — l'opération que les cartes graphiques exécutent le mieux. C'est la source du gain de vitesse dont on parlait au début.

Plusieurs têtes valent mieux qu'une

Une seule attention, c'est un seul « regard » moyen sur la phrase. Or il y a plusieurs choses à surveiller en même temps : à qui renvoie « il », quelle propriété lui est attribuée, quel est le verbe… Si tout est mélangé dans un seul jeu de poids, un mot risque surtout de se regarder lui-même.

Le papier propose donc l'attention multi-têtes : on répète le calcul 8 fois en parallèle, chaque tête ayant ses propres matrices W_Q, W_K, W_V (initialisées différemment, donc libres de se spécialiser). On obtient 8 résultats, qu'on concatène puis qu'on mélange avec une dernière matrice W_O pour retrouver la taille attendue.

Ne te laisse pas tromper par les étiquettes nettes du schéma : dans un vrai modèle, les têtes sont apprises, pas assignées, et leurs rôles sont rarement aussi lisibles. Ce qu'il faut retenir, c'est le principe : plusieurs regards complémentaires, fusionnés en un seul.

Le bloc d'encodeur complet

L'attention n'est qu'une des deux sous-couches d'un bloc. L'autre est le réseau feed-forward : un petit réseau de neurones à deux couches, appliqué séparément à chaque mot avec les mêmes poids. L'attention mélange l'information entre les mots ; le feed-forward retravaille ensuite chaque mot individuellement.

Reste la « colle » : autour de chaque sous-couche, le Transformer ajoute

• une connexion résiduelle (un raccourci) : on additionne l'entrée de la sous-couche à sa sortie. Le signal d'origine n'est jamais perdu, et l'information comme le gradient d'apprentissage traversent plus facilement un réseau profond ;
• une normalisation de couche (layer norm) : on remet les valeurs à une échelle stable pour que l'entraînement ne dérape pas.

Comme la sortie d'un bloc a exactement la même forme que son entrée, on peut empiler les blocs à volonté : 6 dans le papier, des dizaines dans les très grands modèles. La sortie du dernier encodeur est transformée en un jeu de clés K et de valeurs V que chaque bloc du décodeur pourra consulter.

Le décodeur

Écrire un mot à la fois

Le décodeur produit la phrase de sortie un mot à la fois. Il part d'un symbole de début, prédit le premier mot, puis réinjecte ce mot à son entrée pour prédire le suivant, et ainsi de suite jusqu'à produire un symbole de fin de phrase. Comme l'encodeur, il commence par transformer ses entrées en embeddings + positions.

C'est la grande différence avec l'encodeur : ici, on ne peut pas tout traiter d'un coup à l'exécution, puisque chaque mot dépend de celui qu'on vient de produire. (Pour accélérer, les implémentations gardent en mémoire les clés et valeurs déjà calculées des mots précédents : le cache KV.)

Le masque causal

Pendant l'entraînement, en revanche, on connaît déjà la phrase cible complète et on peut calculer toutes les positions en parallèle. Danger : si, pour deviner le mot n° 3, le modèle pouvait lire le mot n° 4, il tricherait — il n'apprendrait rien. D'où le masque causal : avant le softmax, les scores des positions futures sont forcés à −∞, ce qui leur donne un poids de 0.

Bascule entre les deux modes : dans l'encodeur, chaque mot voit toute la phrase ; dans le décodeur, la matrice devient triangulaire — chaque mot ne regarde que lui-même et ses prédécesseurs.

L'attention encodeur–décodeur

Entre la self-attention masquée et le feed-forward, chaque bloc du décodeur ajoute une troisième sous-couche : l'attention encodeur–décodeur. Elle fonctionne comme la self-attention multi-têtes, avec une asymétrie qui change tout : les requêtes viennent du décodeur (ce qu'il est en train d'écrire), mais les clés et les valeurs viennent de l'encodeur (la phrase d'entrée comprise). C'est le pont qui permet au décodeur de se concentrer, à chaque mot produit, sur les bons mots de la phrase source.

Suis ce pont mot à mot. Pour écrire « The blue house » à partir de « La maison bleue », le décodeur regarde-t-il les mots source dans l'ordre ? Avance dans la figure et parie à l'étape de « blue ».

Le décodeur ne parcourt pas la phrase source de gauche à droite : il consulte « bleue » avant « maison », parce que l'anglais place l'adjectif avant le nom. Surtout, il ne choisit jamais un seul mot : à chaque mot écrit, sa requête se compare aux clés de toute la source, les poids forment un mélange des valeurs (ils totalisent 100 %), et ce mélange penche vers un mot. La flèche allumée est celle qui pèse le plus ; la barre montre le mélange complet. Les pourcentages de la figure sont illustratifs, mais le mécanisme est réel : c'est ce qui permet au décodeur de réordonner une phrase en la traduisant.

Du vecteur au mot suivant

Le haut de la pile du décodeur sort un vecteur par position. Il reste à le convertir en… un mot. Deux petites couches s'en chargent :

• une couche linéaire projette le vecteur sur un nouveau vecteur de la taille du vocabulaire — un score (logit) par mot possible ;
• un softmax transforme ces scores en probabilités : toutes positives, de somme 1.

Le mot choisi est alors lu dans cette distribution. Voici le mécanisme sur un exemple où le modèle doit compléter « Le chat dort sur le… » :

Trois façons courantes de choisir le mot, du plus prudent au plus libre :

• Le plus probable (glouton, ou greedy) : on prend toujours le meilleur candidat. Rapide, mais parfois répétitif.
• La recherche en faisceau (beam search) : on garde en parallèle les k meilleures phrases partielles, au lieu d'une seule, et l'on choisit à la fin la meilleure phrase complète. Courant en traduction.
• Le tirage au sort pondéré (échantillonnage) : on tire le mot au hasard selon les probabilités. La température règle alors la prise de risque : basse, le favori écrase tout ; haute, des choix inattendus reviennent. C'est ce curseur qu'on retrouve, sous un nom ou un autre, dans les interfaces d'IA générative.

Comment ça apprend

Tout ce qu'on a décrit — les embeddings, les matrices W_Q, W_K, W_V, les réseaux feed-forward — ce sont des paramètres. Au départ, ils sont aléatoires : le modèle prédit n'importe quoi. L'entraînement, on l'a vu dans les fondations du machine learning, consiste à les ajuster pour que les prédictions collent aux bonnes réponses.

Pour mesurer l'écart, on compare la distribution de probabilités du modèle à la réponse attendue, représentée comme une distribution où le bon mot vaut 1 et tous les autres 0. La mesure standard est l'entropie croisée : la perte vaut −ln(probabilité donnée au bon mot). Si le modèle donne 90 % au bon mot, la perte est faible ; s'il lui donne 1 %, elle est grande. Un pas de descente de gradient pousse ensuite les paramètres dans la direction qui réduit la perte.

À l'échelle réelle, le principe est identique. Pour la traduction, on dispose de millions de paires de phrases. Pour un grand modèle de langage, l'astuce est de prédire le mot suivant sur d'immenses quantités de texte : la « bonne réponse » est déjà dans le texte lui-même, personne n'a besoin d'étiqueter quoi que ce soit.

Et aujourd'hui ?

Le modèle de base du papier original comptait environ 65 millions de paramètres (213 millions pour sa version « big »). Depuis, les modèles ont grossi de plusieurs ordres de grandeur : en juillet 2024, le plus grand de la famille Llama 3 comptait 405 milliards de paramètres ; en juillet 2025, Kimi K2, un modèle « à experts » où seule une partie des paramètres travaille pour chaque mot, annonçait 1 000 milliards au total, dont 32 milliards actifs. L'architecture, elle, est restée remarquablement stable — avec quelques variantes selon ce qu'on garde de l'édifice :

Le même principe a aussi gagné l'image (les Vision Transformers de 2020, qui découpent une photo en petits carrés, traités comme des tokens), le son, la biologie des protéines…

Le décodeur seul est la famille qui écrit le texte des assistants d'aujourd'hui. Où passe donc le texte de départ que tu lui donnes ? Parie, puis bascule entre les deux architectures pour voir ce qui disparaît.

Trois couches disparaissent : la phrase source à part, l'encodeur et l'attention encodeur–décodeur. L'encodeur n'alimentait que cette attention : sans elle, il n'a plus de rôle. Tout le travail revient à la self-attention masquée, qui relit la consigne et les mots déjà écrits comme une seule séquence. Une conséquence pratique : ce que tu écris et ce que le modèle répond partagent la même mémoire de travail, que le cours La fenêtre de contexte détaille.

Une limite à garder en tête : la matrice d'attention compare chaque mot à chaque mot, donc son coût croît avec le carré de la longueur du texte. Doubler la taille du contexte, c'est environ quadrupler ce calcul-là. Une bonne partie de la recherche actuelle consiste à rendre l'attention moins gourmande pour allonger les contextes.

Teste-toi

Quelques questions pour vérifier que les idées clés sont en place. La raison s'affiche après chaque réponse — c'est elle qui compte.

Le vocabulaire en un coup d'œil

Ce qu'il faut retenir

• Un Transformer remplace la lecture séquentielle par l'attention : chaque mot regarde directement tous les autres, et tous les mots sont traités en parallèle.
• L'attention se calcule avec des requêtes, des clés et des valeurs : softmax(Q · Kᵀ / √d) · V.
• Plusieurs têtes offrent plusieurs regards complémentaires, fusionnés ensuite.
• L'encodage positionnel redonne au modèle le sens de l'ordre ; les raccourcis résiduels et la normalisation rendent la pile profonde entraînable.
• Le décodeur génère un mot à la fois, grâce à un masque causal pendant l'entraînement ; un softmax convertit les scores en probabilités, et la température règle la prise de risque.
• Tout est appris en réduisant une perte (l'entropie croisée) sur de très grandes quantités de données.

Pour aller plus loin

• Jay Alammar, The Illustrated Transformer (27 juin 2018) — l'article qui a inspiré ce cours, avec ses schémas d'origine. Citation suggérée par l'auteur : Alammar, J. (2018). The Illustrated Transformer [Blog post]. Consulté le 26 octobre 2026.
• Vaswani et al., Attention Is All You Need (2017) — le papier fondateur, étonnamment lisible : 6 blocs, 512 dimensions, 8 têtes de 64, 65 et 213 millions de paramètres (tableau 3), vocabulaire d'environ 37 000 entrées. Consulté le 26 octobre 2026 (copie ar5iv).
• The Annotated Transformer (groupe NLP de Harvard) — le papier relu ligne à ligne, avec le code en PyTorch.
• Jay Alammar et Maarten Grootendorst, Hands-On Large Language Models — un livre illustré qui prolonge ces idées jusqu'aux modèles d'aujourd'hui.
• Dubey et al., The Llama 3 Herd of Models (31 juillet 2024) — « un Transformer dense de 405 milliards de paramètres » et un contexte jusqu'à 128 000 tokens. Consulté le 26 octobre 2026.
• Dosovitskiy et al., An Image is Worth 16x16 Words (22 octobre 2020) — le Transformer appliqué à des morceaux d'image. Consulté le 26 octobre 2026.
• Hugging Face, LLM course, chapitre 1.4 — les trois familles (encodeur seul, décodeur seul, encodeur–décodeur) et leurs usages. Consulté le 26 octobre 2026.
• Moonshot AI, Kimi K2: Open Agentic Intelligence (28 juillet 2025) — « 32 milliards de paramètres activés et 1 000 milliards au total », un modèle à experts. Consulté le 26 octobre 2026.