Les maths derrière ChatGPT : transformers et algèbre linéaire

Quand on tape une question à ChatGPT et qu’une réponse apparaît mot après mot, on a l’impression d’interagir avec quelque chose d’intelligent. Mais derrière chaque mot généré, il n’y a ni compréhension magique, ni conscience : il y a des multiplications de matrices, des produits scalaires et des exponentielles. L’architecture qui fait tourner ChatGPT s’appelle le transformer, et elle repose entièrement sur l’algèbre linéaire et l’analyse.

L’objectif de cet article est de parcourir, étape par étape, les mathématiques qui se cachent derrière un modèle comme ChatGPT. On va suivre le chemin d’une phrase depuis le texte brut jusqu’à la prédiction du mot suivant, en expliquant chaque opération mathématique rencontrée. Pas besoin de maths très avancées pour suivre : si vous savez ce qu’est une matrice, un produit scalaire et une exponentielle, vous avez les prérequis.

Cet article fait partie de la série Les maths indispensables pour le machine learning.

Prérequis : matrices, produit de matrices, produit scalaire, exponentielle.

Du texte aux nombres : la tokenisation

Un réseau de neurones ne sait manipuler que des nombres. La première étape consiste donc à convertir le texte en une suite de nombres entiers : c’est la tokenisation.

Le modèle dispose d’un vocabulaire fixe V = {1, 2, \ldots, N} contenant environ 50 000 éléments. Chaque élément, appelé token, correspond à un morceau de mot (parfois un mot entier, parfois une syllabe ou un fragment). Le tokenizer découpe le texte d’entrée en une suite de tokens issus de ce vocabulaire.

Exemple concret : la phrase « Le chat mange » pourrait être découpée en trois tokens :

• « Le » → token n°432
•  » chat » → token n°8891
•  » mange » → token n°2507

Le texte est donc transformé en la suite d’entiers (432, 8891, 2507). Cette suite est la seule chose que le modèle reçoit en entrée.

Remarquons que la tokenisation est une étape purement combinatoire : elle associe à chaque morceau de texte un numéro dans un dictionnaire. Il n’y a pas encore de calcul mathématique au sens propre. Mais à partir de l’étape suivante, tout devient de l’algèbre linéaire.

Application ML : les modèles GPT utilisent l’algorithme BPE (Byte Pair Encoding) pour construire leur vocabulaire. Le principe est de fusionner progressivement les paires de caractères les plus fréquentes jusqu’à obtenir un vocabulaire de la taille souhaitée. C’est pour cette raison que les tokens ne correspondent pas toujours à des mots entiers : « mathématiques » peut être découpé en « math », « ém », « atiques ».

Les embeddings : représenter les mots par des vecteurs

La matrice d’embedding

Chaque token est un simple numéro : il ne porte aucune information sémantique. Pour donner du sens aux tokens, on les transforme en vecteurs grâce à une matrice d’embedding.

Cette matrice E a N lignes (une par token du vocabulaire) et d colonnes, où d est la dimension d’embedding (par exemple d = 768 pour GPT-2). La ligne i de E est le vecteur associé au token numéro i :

e_i = E[i, :] \in \mathbb{R}^d

C’est une simple lecture de ligne dans une matrice. Mais le point essentiel est que les valeurs de E ne sont pas fixées à l’avance : elles sont apprises pendant l’entraînement du modèle. Le réseau ajuste progressivement les vecteurs pour que des mots de sens proche se retrouvent représentés par des vecteurs proches.

Mesurer la similarité entre mots

Pourquoi représenter les mots par des vecteurs ? Parce que le produit scalaire entre deux vecteurs mesure leur proximité. Plus précisément, on utilise la similarité cosinus :

\text{sim}(a, b) = \frac{a \cdot b}{\lVert a \rVert \cdot \lVert b \rVert}

Si deux mots ont un sens proche (« roi » et « reine », « courir » et « marcher »), leurs vecteurs d’embedding pointent dans des directions similaires, et leur similarité cosinus est élevée (proche de 1).

Exemple simplifié : imaginons trois mots représentés dans \mathbb{R}^3 (en réalité, la dimension est bien plus grande) :

• « roi » : e_{\text{roi}} = (1 ;0{,}8 ;0{,}2)
• « reine » : e_{\text{reine}} = (0{,}9 ;0{,}9 ;0{,}3)
• « voiture » : e_{\text{voiture}} = (0{,}1 ;0{,}2 ;0{,}95)

Le produit scalaire entre « roi » et « reine » vaut 1 \times 0{,}9 + 0{,}8 \times 0{,}9 + 0{,}2 \times 0{,}3 = 1{,}68, ce qui est élevé. Celui entre « roi » et « voiture » vaut 1 \times 0{,}1 + 0{,}8 \times 0{,}2 + 0{,}2 \times 0{,}95 = 0{,}45, beaucoup plus faible. Les vecteurs reflètent la sémantique.

Pour aller plus loin (prépa) : la lecture d’une ligne dans E correspond à un produit matrice-vecteur. Si on encode le token i par le vecteur one-hot e_i^{\text{oh}} \in \mathbb{R}^N (un 1 en position i, des 0 partout ailleurs), alors E^\top e_i^{\text{oh}} donne exactement la ligne i de E. La matrice d’embedding définit donc une application linéaire de \mathbb{R}^N (l’espace des one-hot) vers \mathbb{R}^d (l’espace des embeddings).

Le mécanisme d’attention : le coeur mathématique du transformer

L’intuition : à quoi le modèle doit-il « faire attention » ?

Considérons la phrase : « Le chat qui dormait sur le canapé s’est réveillé. » Pour prédire le mot suivant après « s’est », le modèle doit comprendre que le sujet est « chat », pas « canapé ». Il doit faire attention au bon mot dans la phrase.

Le mécanisme d’attention résout ce problème : il attribue à chaque token un poids d’importance variable par rapport aux autres tokens. Ces poids sont calculés automatiquement grâce au produit scalaire, ce qui permet au modèle d’apprendre quels mots sont pertinents les uns pour les autres.

Requêtes, clés et valeurs (Q, K, V)

Pour calculer les poids d’attention, chaque vecteur d’embedding x_i \in \mathbb{R}^d est projeté en trois vecteurs distincts :

• la requête (query) : q_i = W_Q x_i — « que cherche ce token ? »
• la clé (key) : k_i = W_K x_i — « quelle information ce token contient-il ? »
• la valeur (value) : v_i = W_V x_i — « quelle information ce token transmet-il ? »

Les matrices W_Q, W_K \in \mathbb{R}^{d_k \times d} et W_V \in \mathbb{R}^{d_v \times d} sont des paramètres appris du modèle. Chaque projection extrait un « point de vue » différent sur le même token.

En regroupant les n tokens de la phrase dans une matrice X \in \mathbb{R}^{n \times d} (une ligne par token), on obtient les trois matrices :

 Q = X  W_Q^\top, \qquad K = X  W_K^\top, \qquad V = X  W_V^\top

Ce sont trois produits de matrices, rien de plus.

Les scores d’attention et le produit scalaire

Le score d’attention entre le token i (qui pose la requête) et le token j (qui propose sa clé) est le produit scalaire :

 s_{ij} = q_i \cdot k_j = q_i^\top k_j

Plus ce produit scalaire est grand, plus le token j est pertinent pour le token i. En matrice, tous les scores se calculent d’un coup :

S = Q  K^\top \in \mathbb{R}^{n \times n}

L’entrée (i, j) de S mesure la compatibilité entre la requête i et la clé j.

Le facteur \sqrt{d_k} : on divise les scores par \sqrt{d_k} avant d’appliquer softmax :

S_{\text{normalisé}} = \frac{Q  K^\top}{\sqrt{d_k}}

Pourquoi ? Si les composantes de q et k sont d’ordre de grandeur 1, alors le produit scalaire q^\top k est une somme de d_k termes, donc d’ordre \sqrt{d_k}. Diviser par \sqrt{d_k} ramène les scores à une échelle raisonnable, ce qui évite que la softmax sature (c’est-à-dire renvoie des poids très proches de 0 ou 1).

Softmax et poids d’attention

On applique la fonction softmax ligne par ligne à la matrice des scores normalisés pour obtenir les poids d’attention :

 A_{ij} = \frac{e^{S_{ij} / \sqrt{d_k}}}{\displaystyle\sum_{l=1}^{n} e^{S_{il} / \sqrt{d_k}}}

Chaque ligne de A est une distribution de probabilité : toutes les entrées sont strictement positives et leur somme vaut 1. Le poids A_{ij} représente l’importance que le token i accorde au token j.

Pour un rappel complet des propriétés de softmax (positivité, somme unitaire, invariance par translation, lien avec la température), voir l’article dédié sur la fonction softmax.

La sortie de l’attention

La sortie est la moyenne pondérée des valeurs selon les poids d’attention :

Z = A V \in \mathbb{R}^{n \times d_v}

Chaque ligne z_i = \sum_{j=1}^{n} A_{ij} v_j : le token i récupère l’information des tokens auxquels il prête attention, proportionnellement à leur poids.

La formule complète tient en une ligne :

\boxed{\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q , K^\top}{\sqrt{d_k}}\right) V}

C’est l’équation fondamentale du transformer. Elle ne fait intervenir que des produits de matrices et la fonction softmax.

Pour aller plus loin (prépa) : pourquoi diviser par \sqrt{d_k} exactement ? Si les composantes de q et k sont des variables aléatoires i.i.d. de moyenne 0 et de variance 1, alors q^\top k = \sum_{l=1}^{d_k} q_l k_l a une espérance nulle et une variance égale à d_k. Diviser par \sqrt{d_k} normalise la variance à 1. C’est exactement le même mécanisme que le paramètre de température de softmax : diviser les scores par \sqrt{d_k} revient à utiliser une température T = \sqrt{d_k}.

Multi-head attention : plusieurs regards simultanés

Pourquoi plusieurs têtes ?

Une seule couche d’attention ne capture qu’un seul type de relation entre les mots. Par exemple, elle pourrait apprendre à relier un verbe à son sujet, mais pas simultanément un adjectif à son nom. Pour pallier ce problème, on exécute plusieurs mécanismes d’attention en parallèle, appelés têtes (heads).

Chaque tête i possède ses propres matrices de projection W_Q^{(i)}, W_K^{(i)}, W_V^{(i)} et produit sa propre sortie :

\text{head}_i = \text{Attention}(X W_Q^{(i)\top}, X W_K^{(i)\top}, X W_V^{(i)\top})

On concatène ensuite les sorties de toutes les têtes et on applique une dernière projection :

 \text{MultiHead}(X) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h)  W_O

La matrice W_O \in \mathbb{R}^{h \cdot d_v \times d} recombine les informations de toutes les têtes en un seul vecteur de dimension d.

Dimensions et coût

Pour garder un coût de calcul comparable à une attention simple, on réduit la dimension de chaque tête. Si le modèle a une dimension d et h têtes, chaque tête opère en dimension :

 d_k = d_v = \frac{d}{h}

Par exemple, GPT-2 utilise d = 768 et h = 12 têtes, donc chaque tête travaille en dimension d_k = 64. Le coût total reste du même ordre qu’une attention en dimension d.

Pour aller plus loin (prépa) : on peut voir la multi-head attention comme une décomposition en somme directe. Chaque tête projette les données dans un sous-espace de dimension d_k. La concaténation des h sorties reconstruit un vecteur de \mathbb{R}^d (puisque h \times d_k = d), et W_O effectue un changement de base dans cet espace reconstruit.

L’architecture transformer simplifiée

Un bloc transformer

Le mécanisme d’attention est le composant central, mais un bloc transformer complet contient quatre étapes :

1. Multi-head attention : calcule les interactions entre tous les tokens (décrit ci-dessus).
2. Connexion résiduelle + normalisation : on ajoute l’entrée à la sortie de l’attention (x + \text{Attention}(x)), puis on normalise. L’addition est triviale algébriquement, mais elle est cruciale pour l’entraînement des réseaux profonds : elle permet au gradient de circuler sans s’atténuer.
3. Réseau feed-forward (FFN) : deux couches linéaires avec une activation non linéaire entre les deux. En formule : \text{FFN}(x) = W_2 , \text{ReLU}(W_1 x + b_1) + b_2. Ce sont encore des multiplications matrice-vecteur.
4. Connexion résiduelle + normalisation (une seconde fois).

Empiler les blocs

L’architecture transformer consiste à empiler L blocs identiques les uns au-dessus des autres. Chaque bloc raffine les représentations des tokens en intégrant davantage de contexte.

Pour donner un ordre de grandeur :

• GPT-2 : L = 12 blocs, d = 768 → 117 millions de paramètres
• GPT-3 : L = 96 blocs, d = 12288 → 175 milliards de paramètres

Après le dernier bloc, la représentation finale de chaque token passe dans une couche linéaire + softmax pour produire une distribution de probabilité sur tout le vocabulaire. Le modèle choisit ensuite le mot suivant parmi cette distribution.

Application ML : on peut estimer le nombre de paramètres d’un transformer. Chaque bloc contient les matrices d’attention (W_Q, W_K, W_V, W_O pour h têtes) et le FFN (deux matrices de dimensions d \times 4d et 4d \times d). Au total, un bloc contient environ 12 , d^2 paramètres. Avec L blocs et la matrice d’embedding (N \times d), le total est d’environ 12 , L , d^2 + N , d. Pour GPT-3 : 12 \times 96 \times 12288^2 \approx 174 milliards, ce qui correspond bien aux 175 milliards annoncés.

L’apprentissage : backpropagation (intuition)

Au départ, toutes les matrices du modèle (E, W_Q, W_K, W_V, W_O, W_1, W_2, \ldots) sont initialisées avec des valeurs aléatoires. Le modèle ne produit que du charabia.

L’entraînement se déroule en trois étapes, répétées des millions de fois sur un immense corpus de texte :

1. Passe avant (forward pass) : le texte traverse le modèle couche par couche. Chaque couche effectue des multiplications de matrices et des applications de fonctions (softmax, ReLU). À la fin, le modèle produit une probabilité pour chaque mot du vocabulaire.
2. Calcul de l’erreur : on compare la prédiction du modèle au vrai mot suivant. L’erreur est mesurée par la cross-entropy, une fonction qui pénalise le modèle quand il attribue une faible probabilité au bon mot.
3. Passe arrière (backpropagation) : le gradient de l’erreur est calculé par rapport à chaque matrice du modèle, en remontant couche par couche grâce à la règle de la chaîne. Chaque matrice W est ensuite mise à jour par descente de gradient :

W \leftarrow W - \eta  \frac{\partial \mathcal{L}}{\partial W}

où \eta est le taux d’apprentissage et \mathcal{L} la cross-entropy.

Après suffisamment d’itérations sur suffisamment de données, les matrices convergent vers des valeurs qui permettent au modèle de prédire le mot suivant de façon cohérente. C’est la seule chose que le modèle apprend : prédire le prochain token. Mais cette tâche simple, appliquée à une quantité colossale de texte, suffit à faire émerger des capacités impressionnantes.

Pour aller plus loin (prépa) : la backpropagation repose sur la composition des Jacobiennes. Si la sortie du modèle s’écrit z = f_L \circ f_{L-1} \circ \cdots \circ f_1(x), alors par la règle de la chaîne : \frac{\partial \mathcal{L}}{\partial x} = J_{f_L} \cdot J_{f_{L-1}} \cdots J_{f_1}, où chaque J_{f_i} est la matrice Jacobienne de la couche i. La backpropagation calcule ce produit de droite à gauche (en partant de la sortie), ce qui est plus efficace car on réutilise les résultats intermédiaires.

Exercices corrigés

Exercice 1 : calcul d’attention pas à pas

On considère n = 3 tokens et une dimension d_k = d_v = 2. Les matrices Q, K, V sont :

Q = \left(\begin{array}{cc} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{array}\right), \qquad K = \left(\begin{array}{cc} 1 & 1 \\ 0 & 1 \\ 1 & 0 \end{array}\right), \qquad V = \left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{array}\right)

1. Calculer la matrice des scores S = Q K^\top.
2. Calculer S' = S / \sqrt{d_k} avec d_k = 2.
3. Appliquer softmax ligne par ligne pour obtenir la matrice d’attention A.
4. Calculer la sortie Z = A V.
5. Interpréter : à quel token le token 3 fait-il le plus attention ?

Correction :

1. On calcule le produit S = Q K^\top :

S = \left(\begin{array}{ccc} 1 \times 1 + 0 \times 1 & 1 \times 0 + 0 \times 1 & 1 \times 1 + 0 \times 0 \\\\ 0 \times 1 + 1 \times 1 & 0 \times 0 + 1 \times 1 & 0 \times 1 + 1 \times 0 \\\\ 1 \times 1 + 1 \times 1 & 1 \times 0 + 1 \times 1 & 1 \times 1 + 1 \times 0 \end{array}\right) = \left(\begin{array}{ccc} 1 & 0 & 1 \\\\ 1 & 1 & 0 \\\\ 2 & 1 & 1 \end{array}\right)

2. On divise par \sqrt{2} \approx 1{,}414 :

 S' = \frac{S}{\sqrt{2}} \approx \left(\begin{array}{ccc} 0{,}707 & 0 & 0{,}707 \\ 0{,}707 & 0{,}707 & 0 \\ 1{,}414 & 0{,}707 & 0{,}707 \end{array}\right)

3. On applique softmax ligne par ligne. Pour la ligne 1 :

e^{0{,}707} \approx 2{,}028, \qquad e^{0} = 1, \qquad e^{0{,}707} \approx 2{,}028

La somme vaut 2{,}028 + 1 + 2{,}028 = 5{,}056, donc :

A_1 = \left(\frac{2{,}028}{5{,}056}, \frac{1}{5{,}056}, \frac{2{,}028}{5{,}056}\right) \approx (0{,}401 ;0{,}198 ;0{,}401)

De même, pour la ligne 2 : A_2 \approx (0{,}401 ;;0{,}401 ;;0{,}198).

Pour la ligne 3 : e^{1{,}414} \approx 4{,}113, e^{0{,}707} \approx 2{,}028, e^{0{,}707} \approx 2{,}028. Somme = 8{,}169.

A_3 \approx (0{,}503 ;0{,}248 ;0{,}248)

La matrice d’attention complète est :

 A \approx \left(\begin{array}{ccc} 0{,}401 & 0{,}198 & 0{,}401 \\ 0{,}401 & 0{,}401 & 0{,}198 \\ 0{,}503 & 0{,}248 & 0{,}248 \end{array}\right)

4. On calcule Z = AV. Pour la ligne 1 :

z_1 = 0{,}401 \times (1, 2) + 0{,}198 \times (3, 4) + 0{,}401 \times (5, 6) = (3{,}00 ;4{,}00)

Pour la ligne 2 : z_2 = 0{,}401 \times (1, 2) + 0{,}401 \times (3, 4) + 0{,}198 \times (5, 6) \approx (2{,}59 ;3{,}59).

Pour la ligne 3 : z_3 = 0{,}503 \times (1, 2) + 0{,}248 \times (3, 4) + 0{,}248 \times (5, 6) \approx (2{,}49 ;3{,}49).

Z \approx \left(\begin{array}{cc} 3{,}00 & 4{,}00 \\ 2{,}59 & 3{,}59 \\ 2{,}49 & 3{,}49 \end{array}\right)

5. Le token 3 a les poids d’attention (0{,}503 ;;0{,}248 ;;0{,}248). Il accorde le plus d’attention au token 1 (poids 0,503). Le score brut s_{31} = 2 était le plus élevé de la ligne 3, ce qui s’explique par le fait que q_3 = (1, 1) et k_1 = (1, 1) sont colinéaires (leur produit scalaire est maximal).

Exercice 2 : propriétés de softmax dans l’attention

1. Montrer que pour tout i, les poids d’attention vérifient \sum_{j=1}^{n} A_{ij} = 1 et A_{ij} > 0.
2. Soit \alpha > 1. On remplace les scores par \alpha , S_{ij}. Montrer que la distribution d’attention devient plus concentrée (le poids maximal augmente). Interpréter en termes de température.
3. Montrer que si tous les scores d’une ligne sont égaux (S_{i1} = S_{i2} = \cdots = S_{in} = c), alors les poids d’attention sont uniformes : A_{ij} = 1/n pour tout j.

Correction :

1. Par définition, A_{ij} = e^{S_{ij}} / \sum_l e^{S_{il}}. Comme e^x > 0 pour tout x \in \mathbb{R}, on a A_{ij} > 0. De plus :

\sum_{j=1}^{n} A_{ij} = \sum_{j=1}^{n} \frac{e^{S_{ij}}}{\sum_l e^{S_{il}}} = \frac{\sum_{j=1}^{n} e^{S_{ij}}}{\sum_l e^{S_{il}}} = 1

C’est une propriété fondamentale de la softmax : elle produit une distribution de probabilité.

2. En multipliant les scores par \alpha > 1, on obtient :

 A'_{ij} = \frac{e^{\alpha S_{ij}}}{\sum_l e^{\alpha S_{il}}}

Posons j^* = \arg\max_j S_{ij}. Pour tout j \neq j^* , on a S_{ij} < S_{ij^*} , donc alpha(S_{ij} - S_{ij^*}) < S_{ij} < S_{ij^*} < 0 . Le rapport A'_{ij}/A'_{ij^*} = e^{\alpha(S_{ij} - S_{ij^*})} est plus petit que e^{S_{ij}-S_{ij^*}} = A_{ij}/A_{ij^*} . Donc le poids maximal A'_{ij^*} augmente par rapport à A_{ij^*} : la distribution est plus « piquée ».

En termes de température : multiplier les scores par \alpha revient à diviser par une température T = 1/\alpha < 1. Plus la température est basse, plus l’attention se concentre sur le token le plus pertinent. À la limite \alpha \to +\infty (température T \to 0), softmax se comporte comme un argmax.

Vérification numérique : avec les scores de l’exercice 1 (ligne 3), le poids maximal passe de 0,503 (\alpha = 1) à 0,807 (\alpha = 3).

3. Si S_{ij} = c pour tout j, alors :

A_{ij} = \frac{e^c}{\sum_{l=1}^{n} e^c} = \frac{e^c}{n , e^c} = \frac{1}{n}

Tous les poids sont égaux : le modèle fait attention à tous les tokens de manière uniforme. C’est le cas où aucun token n’est plus pertinent qu’un autre du point de vue du produit scalaire Q-K.

Exercices d’entraînement

1. On ajoute une même constante c à tous les scores d’une ligne : S'_{ij} = S_{ij}+c pour tout j. Montrer que les poids d’attention ne changent pas. Expliquer pourquoi cette propriété est utile pour la stabilité numérique du calcul.
2. Un modèle utilise h = 4 têtes d’attention et une dimension d = 256. Calculer la dimension d_k de chaque tête. Combien de paramètres contiennent les matrices W_Q, W_K, W_V d’une seule tête ? Combien pour les 4 têtes plus la matrice W_O ?
3. On considère un transformer avec L = 12 couches, d = 768 et un vocabulaire de N = 50,000 tokens. En utilisant l’approximation du nombre de paramètres par bloc (\approx 12 , d^2) et la matrice d’embedding (N \times d), estimer le nombre total de paramètres. Comparer avec les 117 millions de paramètres de GPT-2.

FAQ