Pourquoi les Transformers sont-ils devenus incontournables en IA ?

POURQUOI LES TRANSFORMERS ONT-ILS CHANGÉ LA DONNE ?

La plupart des explications sur les Transformers commencent par leur architecture finale : des couches empilées, des clés, des requêtes, des valeurs, et une attention calculée avec des produits scalaires. Mais pourquoi cette structure ? Pourquoi ne pas utiliser simplement des réseaux de neurones classiques ? Ces questions semblent évidentes aujourd’hui, alors que les Transformers dominent le paysage de l’IA en 2026. Pourtant, comprendre pourquoi cette architecture fonctionne si bien pourrait nous aider à inventer la prochaine révolution.

Imaginons un instant que l’histoire ne s’arrête pas là. Les Transformers ne seront pas éternels : chaque technologie est remplacée un jour. Plus nous comprenons leurs mécanismes profonds, plus nous pourrons accélérer cette évolution. Et ce qui est fascinant, c’est que leur forme générale n’est pas un hasard. En partant de quelques contraintes de conception, on peut retrouver presque naturellement l’alphabet de matrices qui les compose.

LES RÉSEAUX DE NEURONES RÉCURRENTS : POURQUOI ILS NE SUFFISAIENT PLUS

Pour saisir l’importance des Transformers, il faut remonter à 2014, quand les réseaux de neurones récurrents (RNN) dominaient le traitement des séquences. Les RNN, comme les LSTM (Long Short-Term Memory), étaient capables de mémoriser des informations sur le long terme. Pourtant, ils partageaient un défaut majeur : leur mémoire était fixe et compressée.

Prenons une analogie simple. Imaginez que vous encodez la phrase « J’ai cinq euros » dans la mémoire d’un RNN. La mémoire, représentée par un rectangle gris, contient cette information. Maintenant, ajoutez « et quarante centimes dans ma poche ». Le rectangle gris doit maintenant contenir plus d’informations, mais sa taille reste la même. Résultat : certaines données sont écrasées, comme si vous essayiez de faire tenir une encyclopédie dans une boîte à chaussures. Impossible de se souvenir précisément de chaque détail ou de suivre des instructions complexes.

L’INVENTION DE L’ATTENTION : UNE MÉMOIRE QUI GRANDIT

En 2014, Bahdanau et al. ont proposé une solution révolutionnaire : l’attention. L’idée ? Conserver toute l’historique des états du RNN dans une mémoire qui s’étend avec la séquence d’entrée. Plus la phrase est longue, plus la mémoire grandit, sans jamais écraser les informations précédentes.

Dans un RNN classique, chaque état est compressé et transmis de gauche à droite, comme une chaîne où chaque maillon dépend du précédent. Avec l’attention, chaque état a un accès direct à toute l’histoire des entrées. Les connexions rouges sur le schéma représentent ces nouvelles liaisons : chaque état est relié à tous les précédents. Plus besoin de compression .

Mais cette avancée posait un nouveau problème : la vitesse d’entraînement. Les RNN doivent être calculés étape par étape, car chaque sortie dépend de la précédente. Résultat : avec des séquences longues, l’entraînement devient lent et ne peut pas être parallélisé sur GPU. Les calculs doivent se faire dans l’ordre, comme si vous deviez lire un livre page par page sans sauter de chapitre.

DE L’ATTENTION AU TRANSFORMER : SUPPRIMER LA RÉCURRENCE

En 2017, Vaswani et al. ont eu une idée radicale : et si on supprimait complètement les connexions récurrentes ? Et si la mémoire dynamique de l’attention suffisait ? Le schéma ci-dessous montre cette idée : plus de flèches de gauche à droite, seulement des connexions rouges entre tous les états.

Comparons les deux approches. Dans un réseau récurrent, chaque couche doit être calculée étape par étape. Pour une séquence de 5 mots, il faut 5 étapes pour la première couche, puis 5 pour la suivante, etc. En revanche, dans un réseau non récurrent, une fois que la première couche est calculée, toutes les suivantes peuvent être traitées en parallèle. Pour une séquence de 5 mots, seules 2 étapes suffisent, quelle que soit la longueur de la séquence .

GÉNÉRER DES POIDS DYNAMIQUES : LE DÉFI DES SÉQUENCES VARIABLES

Passons maintenant à la question cruciale : comment attribuer des poids à ces connexions rouges ? Dans un réseau classique, les poids sont fixes et appris pendant l’entraînement. Mais ici, les séquences d’entrée varient en longueur. Impossible de prévoir à l’avance la taille du réseau.

Il faut donc une fonction capable de générer des poids dynamiquement, en fonction des entrées. Zoomons sur une unité particulière avec une séquence de 3 mots : x1, x2, x3. Pour rendre le schéma complet, ajoutons des connexions de saut (skip connections). Ces connexions ajoutent les entrées x1, x2, x3 aux sorties O1, O2, O3. Elles permettent aux transformations intermédiaires de se concentrer sur l’ajustement des entrées plutôt que de les préserver, comme si on corrigeait une recette de cuisine en ajoutant une pincée de sel.

Les connexions de saut ont été popularisées par les réseaux ResNet en 2015. Elles améliorent considérablement les performances en évitant la dégradation des gradients.

BRISER LA SYMÉTRIE : LA NAISSANCE DES REQUÊTES ET DES CLÉS

Revenons à notre fonction de Génération de poids. Un poids pourrait dépendre de la sortie de l’unité source et de sa position dans la séquence. Mais pour briser la symétrie, il faut aussi prendre en compte la sortie de l’unité de destination. Cependant, cela crée un cercle vicieux : pour calculer le poids, il faut déjà connaître la sortie de l’unité de destination.

Une autre solution : rendre les poids nuls pour toutes les entrées sauf celle que l’unité modifie. Mais cela donne un réseau sans mémoire, où chaque unité fonctionne de manière isolée. La symétrie doit être brisée, mais ce n’est pas suffisant. Il faut aussi une interaction non nulle entre les unités et les états passés.

Chaque poids est une matrice qui multiplie les vecteurs d’entrée en sortie. Notre fonction doit donc générer des matrices dynamiques. Mais attention : si on paramétrise chaque élément de la matrice séparément, le nombre de paramètres explose. Pour une matrice de taille 1000x1000, cela représente un million de paramètres à apprendre .

RÉDUIRE LE NOMBRE DE PARAMÈTRES : LA SOLUTION DES MATRICES FIXES

Pour éviter cette explosion, une solution consiste à utiliser une combinaison linéaire de matrices fixes. Au lieu de générer une matrice dynamique complexe, on utilise un petit nombre de matrices statiques (V) et des coefficients dynamiques. Les V sont les matrices que l’on apprend pendant l’entraînement, tandis que les coefficients sont calculés dynamiquement.

Décomposons une de ces fonctions en deux parties : une fonction non interactive à gauche, une interaction pure au centre, et une autre fonction non interactive à droite. Le problème ? Les fonctions non interactives créent une dépendance globale : si le terme de gauche est grand pour une unité, il le sera pour toutes les unités connectées à x1. Pour éviter cela, gardons seulement la fonction d’interaction centrale, que nous appellerons fonction d’attention.

POURQUOI LE PRODUIT SCALAIRE EST-IL PARFAIT POUR L’ATTENTION ?

Une candidate pour la fonction d’attention était la fonction tanh utilisée par Bahdanau. Mais tanh est faiblement interactive : ses contours sont déformés, mais restent proches d’une somme linéaire. Visualisons cela avec deux entrées x1 et x3. Si une unité a besoin d’une grande valeur positive, elle ne peut l’obtenir que dans une seule région du graphique. Si une autre unité partage x1 mais a besoin d’une valeur négative, elle sera bloquée, sauf si x3 compense avec une grande valeur positive. Le réseau manque de flexibilité.

En revanche, le produit de deux nombres est hautement interactif. Ses contours forment un angle droit, permettant une grande variété de combinaisons. De plus, les GPU excellent dans le calcul des produits scalaires. Pourquoi ne pas utiliser un réseau de neurones plus profond pour modéliser une fonction d’attention plus complexe ? Parce que le nombre de calculs d’attention croît quadratiquement avec la longueur de la séquence. Mieux vaut garder la fonction simple et itérer sur les couches.

Pour des entrées multidimensionnelles, le produit scalaire classique ne suffit pas. Il faut un produit scalaire dans un sous-espace particulier, appelé forme bilinéaire. Cette forme est plus générale et se réduit au produit scalaire classique quand la matrice A est l’identité.

LE CACHE CLÉ-VALEUR : UNE OPTIMISATION INDISPENSABLE

Calculer l’attention pour chaque paire de mots dans une longue conversation est coûteux en mémoire. Par exemple, pour une séquence de 5 000 mots, 50 couches, 20 matrices V différentes, et des vecteurs de dimension 1 000, le cache clé-valeur occupe 10 Go de mémoire. Réduire la dimension des vecteurs de 1 000 à 200 divise cette taille par 5, soit 2 Go. Mais comment faire ?

La solution : projeter les vecteurs dans un espace de dimension réduite r. Pour cela, on factorise la matrice A en deux matrices Wq et Wk, qui projettent les vecteurs x1 et x3 dans un espace de dimension r. Le produit scalaire final se fait alors dans cet espace réduit. Wq et Wk sont les matrices apprises dans l’architecture originale des Transformers.

LES MATRICES Q, K ET V : LE CŒUR DU TRANSFORMER

Intégrons cette fonction d’attention dans notre somme de matrices. Chaque poids entre x1 et O3 est une somme pondérée par des coefficients d’attention. Ces coefficients sont calculés comme des produits scalaires entre une requête (Wq * x3) et une clé (Wk * xi), suivis d’une normalisation softmax. Les valeurs (V * xi) sont ensuite pondérées par ces scores pour produire la sortie finale.

Pour un Transformers autoregressif, chaque position de la séquence ne peut accéder qu’aux positions précédentes. On utilise une matrice de masquage M pour bloquer les connexions futures. La sortie finale S est une somme pondérée des valeurs, où les poids sont normalisés par softmax.

Pourquoi écrire cela sous forme matricielle ? Parce que les GPU excellent dans le calcul matriciel, même si cela implique de calculer des produits scalaires inutiles qui seront masqués ensuite.

LA NORMALISATION SOFTMAX : TRIER LES INFORMATIONS PERTINENTES

Quand la séquence devient très longue, la somme des coefficients d’attention peut devenir ingérable. La solution ? Normaliser ces coefficients pour qu’ils somment toujours à 1, quelle que soit la longueur de la séquence. La softmax est la transformation idéale : elle exponentie chaque coefficient et divise par la somme de tous les exponentiés. Résultat : le coefficient le plus élevé est poussé vers 1, tandis que les autres sont écrasés vers 0. Le paramètre tau contrôle l’agressivité de cette transformation.

La softmax permet aussi d’obtenir une forme de sparsité douce : seuls les mots les plus pertinents contribuent significativement à la sortie. Dans une phrase comme « Le chat dort sur le canapé », les mots « chat » et « canapé » auront des scores d’attention élevés, tandis que « le » ou « sur » seront ignorés.

L’ÉQUATION ICONIQUE DU TRANSFORMER : UNE RÉVOLUTION EN MATRICES

Réécrivons notre somme normalisée sous forme matricielle pour une position L donnée. La requête q est le vecteur Wq * xL, les clés sont les lignes de la matrice K (Wk * xi pour chaque xi), et les valeurs sont les lignes de la matrice V (V xi pour chaque xi). Le produit q K^T donne un vecteur de scores d’attention entre q et chaque clé. La softmax normalise ces scores, puis on fait une somme pondérée des valeurs V en utilisant ces scores.

Pour l’ensemble de la séquence, on écrit cela sous forme matricielle : S = softmax(Q K^T) V. Chaque ligne de S est la sortie à une position donnée. La matrice de masquage M empêche les connexions futures en ajoutant -∞ aux scores d’attention correspondants, ce qui les fait disparaître après softmax.

Voilà comment les clés, requêtes et valeurs s’assemblent pour former l’architecture des Transformers. Leur efficacité vient de cette combinaison : des poids dynamiques générés par des produits scalaires, une mémoire qui grandit avec la séquence, et une parallélisation totale grâce à l’absence de récurrence.

ET LE MLP DANS TOUT ÇA ? UNE DÉCOUVERTE SURPRENANTE

Terminons par une curiosité : le bloc de propagation avant (MLP), souvent négligé, peut être vu comme un stockage clé-valeur à part entière. Chaque couche MLP stocke des associations entre entrées et sorties, comme une base de données interne. Cette découverte montre que même les éléments apparemment simples des Transformers cachent des mécanismes profonds.

QUELLE EST LA PROCHAINE ÉTAPE POUR L’IA ?

Les Transformers ont dominé l’IA pendant près de dix ans. Mais leur forme n’est pas gravée dans le marbre. En comprenant pourquoi ils fonctionnent, nous pouvons imaginer des architectures encore plus efficaces. Peut-être un jour remplacerons-nous les produits scalaires par des mécanismes plus intelligents, ou trouverons-nous une façon de réduire encore la mémoire des caches clé-valeur. Une chose est sûre : l’histoire des Transformers n’est pas finie.

Ce qui est fascinant, c’est que leur architecture n’est pas le fruit du hasard. Elle émerge naturellement de contraintes de conception : parallélisation, mémoire dynamique, et interaction entre unités. Les clés, requêtes et valeurs ne sont pas des concepts arbitraires, mais des solutions élégantes à des problèmes concrets. Et c’est pour cela qu’ils ont changé l’IA à jamais.