Mathématiques on kenji.blog

【Pour les débutants】Décrypter la structure mathématique du modèle Transformer

Fri, 11 Sep 2026 22:00:00 +0900

Introduction : Pourquoi apprendre les mathématiques du Transformer ?

Il n’est pas exagéré de dire que le “Transformer” est l’architecture qui a réécrit l’histoire du traitement du langage naturel (NLP) moderne et de l’IA dans son ensemble. Ce modèle, proposé pour la première fois dans l’article “Attention Is All You Need” publié par des chercheurs de Google en 2017, sert de cœur aux grands modèles de langage (LLM) qui dominent actuellement le monde, tels que la série GPT d’OpenAI (la technologie sous-jacente de ChatGPT), BERT de Google et Claude d’Anthropic.

Cependant, bien que l’on trouve souvent des explications qualitatives sur le fonctionnement du Transformer telles que “comprendre le contexte en utilisant l’Attention (mécanisme d’attention)”, il existe actuellement très peu d’explications approfondies destinées aux débutants sur la structure mathématique qui se cache derrière. Pour vraiment comprendre comment l’IA traite les “mots” comme des “formules mathématiques” et génère des textes étonnamment naturels, il est essentiel de décrypter son mécanisme mathématique.

Dans cet article, destiné à ceux qui ont des connaissances de base en mathématiques et en programmation (ceux qui comprennent les concepts de matrices et de dérivées au niveau du lycée), nous allons décrypter de manière exhaustive et compréhensible les structures mathématiques qui constituent le cœur du Transformer, telles que le “mécanisme de Self-Attention”, le modèle “Requête-Clé-Valeur (Q/K/V)”, la “normalisation par la fonction Softmax” et le “Positional Encoding”.

Vous pourriez être submergé par la liste des formules, mais chaque calcul a une “signification” claire. À la fin de cet article, vous devriez comprendre que le Transformer n’est pas simplement une boîte noire magique, mais l’aboutissement de mathématiques et de statistiques conçues avec précision.

1. Les limites des méthodes traditionnelles et l’innovation du Transformer

Avant l’apparition du Transformer, le courant principal du traitement du langage naturel était les réseaux de neurones récurrents (RNN) et leurs dérivés, les LSTM (Long Short-Term Memory). Les RNN ont été conçus pour traiter des données chronologiques et lisent les phrases mot par mot, dans l’ordre, depuis le début.

Cependant, les RNN présentaient deux faiblesses fatales.

Difficulté d’apprentissage des dépendances à long terme : Lorsque les phrases deviennent longues, les informations des mots saisis au début s’estompent avant d’atteindre la fin (problème de la disparition du gradient).
Impossibilité de calcul parallèle : Comme les mots doivent être traités séquentiellement, il est difficile d’effectuer des calculs parallèles à grande échelle à l’aide de GPU, ce qui nécessite un temps énorme pour l’apprentissage.

Le Transformer a complètement abandonné la structure des RNN et a provoqué un changement de paradigme consistant à capturer le contexte en utilisant uniquement l’“Attention”. Grâce à cela, quelle que soit la longueur de la séquence, il n’y a aucune perte d’information, et il est devenu possible de paralléliser les calculs pour maximiser les performances du GPU.

2. L’architecture globale du Transformer

Commençons par examiner l’architecture globale du Transformer. Le Transformer est composé principalement de deux blocs : l’“Encoder” (encodeur) et le “Decoder” (décodeur). Si l’on prend l’exemple d’une tâche de traduction, l’Encoder convertit la langue source (ex : anglais) en une représentation vectorielle mathématique, et le Decoder génère la langue cible (ex : japonais) à partir de cette représentation vectorielle.

Le diagramme ci-dessous est une simplification de la structure interne du bloc Encoder.

graph TD A["Jetons d'entrée"] --> B["Intégration d'entrée"] B --> C["Encodage positionnel"] C --> D["Multi-Head Self-Attention"] D --> E["Ajout et normalisation de couche"] E --> F["Réseau Feed Forward"] F --> G["Ajout et normalisation de couche"] G --> H["Sortie vers la couche suivante"] C -.->|"Connexion résiduelle"| E E -.->|"Connexion résiduelle"| G

À partir d’ici, examinons étape par étape les opérations mathématiques effectuées dans chaque composant.

3. Vectorisation des mots et encodage positionnel (Positional Encoding)

Un ordinateur ne peut pas comprendre le texte tel quel. Le texte d’entrée est d’abord divisé en unités appelées “jetons” (Tokens), et chacun est converti en un vecteur de longueur fixe. C’est ce qu’on appelle l’Input Embedding (Intégration d’entrée).

3.1 Les mathématiques de l’Input Embedding

Soit $V$ la taille du vocabulaire et $d_{model}$ la dimension des vecteurs d’intégration (dans l’article original, $d_{model} = 512$). Chaque mot $w_i$ est converti en un vecteur $x_i \in \mathbb{R}^{d_{model}}$ à l’aide de la matrice d’intégration $W_E \in \mathbb{R}^{V \times d_{model}}$.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Ainsi, la phrase entière est représentée comme une matrice $X \in \mathbb{R}^{N \times d_{model}}$ ($N$ étant la longueur de la phrase).

3.2 La nécessité et les formules du Positional Encoding (Encodage positionnel)

Le Transformer ne traite pas les mots séquentiellement comme les RNN, mais traite tous les mots simultanément et en parallèle. Bien que cela soit un grand avantage du point de vue de la vitesse de calcul, cela pose le problème que l’information importante de “l’ordre des mots” est perdue. Par exemple, “Un chien mord un homme” et “Un homme mord un chien” ont le même ensemble de mots en entrée, mais des significations complètement différentes.

Le Positional Encoding a été conçu pour fournir cette information d’ordre des mots au modèle. Le Positional Encoding $PE$ pour la dimension $i$ du mot situé à la position $pos$ est calculé à l’aide des fonctions trigonométriques suivantes.

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Où $pos$ est la position du mot ($0, 1, 2, \dots, N-1$), et $i$ est l’indice de la dimension du vecteur ($0, 1, \dots, d_{model}/2 - 1$).

Pourquoi utiliser le sinus et le cosinus ?

À première vue, cela ressemble à une formule très complexe et étrange, mais il y a une raison mathématique profonde à cela. En utilisant des fonctions trigonométriques, le modèle peut facilement apprendre non seulement les “positions absolues” mais aussi les différences de “positions relatives”.

Rappelez-vous les formules d’addition trigonométriques apprises au lycée.

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

Le Positional Encoding d’une position $pos + k$ décalée d’un offset $k$ par rapport à une position $pos$ peut être exprimé comme une combinaison linéaire du Positional Encoding de la position $pos$. C’est-à-dire, en utilisant une matrice $M_k$, cela peut s’écrire ainsi :

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

Ainsi, le mécanisme d’Attention peut facilement reconnaître la distance relative “à quelle distance” se trouvent les mots les uns par rapport aux autres grâce au calcul du produit scalaire. De plus, en combinant plusieurs ondes de sinus et cosinus de longueurs d’onde différentes, il y a l’avantage de pouvoir générer un vecteur de position unique, quelle que soit la longueur de la phrase.

La matrice d’entrée finale $X_{input}$ est la somme des vecteurs d’intégration des mots et de cet encodage positionnel.

$$ X_{input} = X + PE $$

4. Les mathématiques profondes de la Self-Attention (Mécanisme d’auto-attention)

Nous entrons enfin dans le composant le plus important du Transformer, la Self-Attention (mécanisme d’auto-attention). L’objectif de la Self-Attention est de “calculer le degré de pertinence entre tous les mots de la phrase et de mettre à jour le vecteur de chaque mot vers une représentation plus riche qui prend en compte le contexte”.

Ici, nous utilisons l’analogie d’un “système de recherche”.

Query (Q) : Requête (terme de recherche). “Quelle est l’information que je cherche maintenant ?”
Key (K) : Clé (en-tête). “Quelle est l’information que je possède ?”
Value (V) : Valeur (entité). “Quelle est l’information que je fournis réellement ?”

4.1 Génération des matrices $Q, K, V$

Pour la matrice d’entrée $X \in \mathbb{R}^{N \times d_{model}}$ (pour simplifier, nous ignorons la taille du batch ici), nous calculons la requête $Q$, la clé $K$ et la valeur $V$ en multipliant par les matrices de poids apprenables $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$. (Généralement $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Ici, $Q, K, V$ sont toutes des matrices de $\mathbb{R}^{N \times d_k}$.

4.2 Calcul de l’Attention Score (Produit scalaire)

Pour mesurer à quel point la Query de chaque mot est liée aux Key de tous les autres mots, nous calculons le produit scalaire des vecteurs. Écrit en opérations matricielles, cela donne :

$$ \text{Scores} = Q K^T $$

Chaque élément $s_{ij}$ de la matrice $\text{Scores} \in \mathbb{R}^{N \times N}$ obtenue par ce calcul représente le produit scalaire entre la Query du $i$-ème mot et la Key du $j$-ème mot, c’est-à-dire “l’intensité de la pertinence”.

4.3 Mise à l’échelle (Scale)

Il y a un problème avec le calcul du score par produit scalaire. Lorsque la dimension des vecteurs $d_k$ augmente, la valeur du produit scalaire devient extrêmement grande ou petite.

Prouvons-le mathématiquement. Supposons que chaque élément de la requête $q \sim \mathcal{N}(0, 1)$ et chaque élément de la clé $k \sim \mathcal{N}(0, 1)$ suivent des distributions normales centrées réduites indépendantes. Nous cherchons la moyenne et la variance du produit scalaire $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Moyenne : Comme $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, la moyenne de la somme est aussi $0$. Variance : La variance de $q_i k_i$ est, par indépendance, $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Par conséquent, la variance totale du produit scalaire est égale à la dimension $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Si la variance devient grande, la fonction Softmax appliquée par la suite entraînera une “disparition du gradient” où les gradients des valeurs autres que le maximum deviendront extrêmement petits, ce qui empêchera l’apprentissage de progresser. Pour éviter cela, nous divisons (mettons à l’échelle) les scores par $\sqrt{d_k}$ afin de maintenir la variance toujours à $1$.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Probabilisation par la fonction Softmax

Afin de convertir les scores obtenus en une distribution de probabilité (poids) dont la somme est de $1$, nous appliquons la fonction Softmax ligne par ligne.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

La matrice $A \in \mathbb{R}^{N \times N}$ est appelée matrice de poids d’attention (Attention Weight). Si l’on regarde chaque ligne $i$ de cette matrice, “dans quelle mesure faut-il prêter attention au mot $j$ pour comprendre le mot $i$” est exprimé par une valeur allant de 0 à 1.

4.5 Somme pondérée des Value

Enfin, en utilisant la matrice Attention Weight $A$ obtenue, nous calculons la somme pondérée de la matrice Value $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

La matrice $Z \in \mathbb{R}^{N \times d_v}$ produite par cette opération est un ensemble de “représentations vectorielles de mots mises à jour en tenant compte du contexte”. C’est la vue d’ensemble du Scaled Dot-Product Attention défini dans l’article.

5. Multi-Head Attention (Attention multi-têtes)

Avec un seul calcul d’Attention (tête unique), il est possible de ne capturer le contexte que d’un seul point de vue (par exemple, “la relation grammaticale”). Par conséquent, pour capturer simultanément les diverses relations sémantiques et syntaxiques du langage (comme “sujet et prédicat”, “pronom et son référent”, etc.), la Multi-Head Attention a été introduite.

La génération de $Q, K, V$ et le calcul de l’Attention précédents sont effectués en parallèle $h$ fois (nombre de têtes. Dans l’article original $h=8$).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Ici, $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ sont des matrices de poids apprenables dédiées à la $i$-ème tête.

Les résultats $\text{head}_i \in \mathbb{R}^{N \times d_v}$ de chaque tête sont concaténés horizontalement.

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Habituellement, on paramètre de telle sorte que $h \cdot d_v = d_{model}$, donc la dimension après concaténation revient à $d_{model}$, identique à l’entrée. Enfin, cette matrice est multipliée par une matrice de poids $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ pour obtenir la sortie finale.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Entrée X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Tête 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Tête 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Tête h"] H1 & H2 & HN --> C["Concaténer"] C --> WO["Multiplier par WO"] WO --> OUT["Sortie Multi-Head"]

6. Réseau de neurones Feed-Forward (FFN)

La sortie de la Multi-Head Attention est ensuite introduite dans un Position-wise Feed-Forward Network (FFN). Il s’agit d’un réseau de neurones entièrement connecté à deux couches appliqué “indépendamment à chaque position (mot)” de la séquence.

Exprimé par des formules, cela donne :

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Ici, $\max(0, z)$ représente la fonction d’activation ReLU (Rectified Linear Unit) (dans les modèles récents, GELU ou SwiGLU sont souvent utilisés).

Le rôle de ce réseau est très important. Le mécanisme d’Attention apprend les “relations entre les mots (relations spatiales et séquentielles)”, tandis que le FFN se charge de la “transformation de caractéristiques non linéaires du vecteur de chaque mot lui-même”. Habituellement, la dimension est temporairement considérablement augmentée par le poids $W_1$ de la première couche (par exemple, augmentée 4 fois, de $d_{model}=512$ à $d_{ff}=2048$), et après avoir effectué des calculs complexes dans l’espace des caractéristiques, elle est ramenée à sa dimension d’origine par le poids $W_2$ de la deuxième couche. Cette “expansion et réduction de dimension” augmente considérablement la puissance expressive du modèle.

7. Connexions résiduelles (Residual Connection) et Layer Normalization

En apprentissage profond, lorsque les couches du réseau sont approfondies, il y a un problème de disparition ou d’explosion des gradients pendant l’apprentissage, ce qui empêche un apprentissage correct. Pour éviter cela, des connexions résiduelles (Residual Connection) et une Layer Normalization (normalisation de couche) sont placées autour de chaque sous-couche (Attention et FFN) du Transformer.

Écrit mathématiquement, la sortie de la sous-couche est traitée comme suit :

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Connexion résiduelle ($x + \text{Sublayer}(x)$)

L’entrée $x$ est directement ajoutée à la sortie de la sous-couche. Ainsi, lors de la rétropropagation, le gradient est transmis directement aux couches peu profondes via ce raccourci, ce qui stabilise l’apprentissage même si les couches sont profondes.

7.2 Les mathématiques de la Layer Normalization

La Layer Normalization est une technique de normalisation des données en calculant la moyenne et la variance le long de la dimension des caractéristiques. Pour une entrée de taille de batch $B$, de longueur de séquence $N$ et de dimension $d_{model}$, la normalisation est effectuée sur un seul vecteur de mot $x \in \mathbb{R}^{d_{model}}$.

On calcule la moyenne $\mu$ et la variance $\sigma^2$.

$$ \mu = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} x_i $$ $$ \sigma^2 = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} (x_i - \mu)^2 $$

Et nous obtenons la sortie normalisée $\hat{x}$.

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

($\epsilon$ est une petite constante pour éviter la division par zéro. $\gamma, \beta$ sont des paramètres apprenables de mise à l’échelle et de décalage)

La raison d’adopter la normalisation de couche (Layer Normalization) plutôt que la normalisation de batch (Batch Normalization) est que lors du traitement de données séquentielles de longueur variable comme des phrases, les statistiques entre les batchs ont tendance à devenir instables. Grâce à la Layer Normalization, le Transformer peut effectuer un apprentissage stable indépendamment de la taille du batch.

8. Structures spécifiques au décodeur : Masked Attention et Cross-Attention

La structure expliquée jusqu’à présent est celle de l’encodeur. Dans le bloc décodeur qui génère les phrases, la structure est légèrement différente.

8.1 Masked Multi-Head Attention

Le rôle du décodeur est de “prédire le mot suivant à partir des mots passés”. Par conséquent, regarder les “mots futurs” pendant l’entraînement s’apparenterait à tricher. L’opération mathématique pour éviter cela est le Masking (masquage).

À la matrice de scores $Q K^T$, on ajoute une matrice de masque $M$ qui définit des valeurs très petites proches de $-\infty$ dans la partie triangulaire supérieure (correspondant aux informations futures).

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

Lors du calcul de la fonction Softmax, puisque $\exp(-\infty) = 0$, l’Attention Weight pour les mots futurs devient complètement $0$. Cela permet une génération autorégressive en préservant la causalité (Causality).

8.2 Encoder-Decoder Cross-Attention

La deuxième sous-couche du décodeur est la Cross-Attention qui se réfère à la sortie de l’encodeur. Ici, $Q$ est généré à partir de la couche de décodage précédente, mais $K$ et $V$ sont générés à partir de la sortie de la dernière couche de l’encodeur.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

Grâce à ce calcul, le modèle peut apprendre, par exemple dans une tâche de traduction, “à quelle partie de la phrase en langue étrangère d’origine le mot actuellement traduit est-il fortement lié”.

9. Complexité de calcul et mathématiques de l’optimisation moderne

Le Transformer est un modèle formidable, mais il a aussi des “faiblesses” dues à sa structure mathématique. Faites attention à la complexité de calcul de la Self-Attention. Le calcul de la matrice de scores $Q K^T$ nécessite de multiplier une matrice de $(N \times d_k)$ par une matrice de $(d_k \times N)$, sa complexité de calcul est donc de $O(N^2 \cdot d_{model})$.

En d’autres termes, la quantité de calculs et l’utilisation de la mémoire augmentent de manière quadratique par rapport à la longueur de la séquence $N$. Cela ne pose pas de problème si la phrase est courte, mais si vous essayez de saisir un long contexte tel qu’un livre entier dans un LLM, $N$ atteint des dizaines à des centaines de milliers, et la mémoire du GPU s’épuise immédiatement avec le calcul classique de l’Attention.

Pour briser cette malédiction de $O(N^2)$, diverses optimisations basées sur des approches mathématiques et matérielles ont été proposées ces dernières années. Un exemple typique est FlashAttention. FlashAttention est un algorithme qui divise le calcul de l’Attention en tuiles (Tiling) afin de minimiser le transfert de données (accès mémoire) entre la hiérarchie de la mémoire GPU (SRAM et HBM). Bien que mathématiquement il produise exactement le même résultat que l’Attention standard (Exact Attention), les optimisations au niveau matériel permettent de réaliser une accélération spectaculaire et une réduction de la mémoire, rendant possible des modèles à long contexte comme GPT-4.

De plus, des recherches sur Sparse Attention et Linear Attention, qui estiment la complexité de calcul à $O(N \log N)$ ou $O(N)$, sont également activement menées.

10. Image d’implémentation (Pseudo-code de type PyTorch)

Si l’on transpose la structure mathématique vue jusqu’ici dans un code de programmation réel (Python / PyTorch), on s’aperçoit qu’elle peut être décrite de manière étonnamment simple. Voici le pseudo-code de la partie centrale de la Self-Attention.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # formes de q, k, v : [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Calcul du score par produit scalaire : Q * K^T
 # Transposer les deux dernières dimensions et calculer le produit matriciel
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Mise à l'échelle
 scores = scores / math.sqrt(d_k)

 # 3. Masking (dans le cas de la Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Probabilisation par Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Multiplication de la matrice Value
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Vous pouvez voir que la formule mathématique $Q K^T / \sqrt{d_k}$ est implémentée de manière intuitive comme torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k). C’est un aspect très intéressant de l’apprentissage profond de voir que les théories mathématiques peuvent être réalisées en quelques lignes de code avec l’aide de bibliothèques d’optimisation avancées.

Conclusion : La forme de l’“intelligence” vue à travers les mathématiques

Dans cet article, nous avons décrypté la structure mathématique profonde du modèle Transformer.

L’Embedding qui mappe les mots dans un espace vectoriel multidimensionnel, le Positional Encoding qui exprime les informations de position par la synthèse d’ondes triangulaires, et le mécanisme de Self-Attention qui est un calcul de produit scalaire matriciel né de l’analogie de la recherche d’informations. Chacun de ces composants n’est qu’une accumulation de mathématiques fondamentales telles que l’algèbre linéaire, le calcul différentiel et intégral, et les probabilités et statistiques.

Cependant, lorsque ces simples opérations matricielles se superposent sur de nombreuses couches et apprennent des modèles à partir d’énormes ensembles de données via des milliards et des centaines de milliards de paramètres, une “forme d’intelligence” émerge, semblant comprendre nos “mots”, effectuer des raisonnements logiques et parfois générer des idées créatives.

Comme l’indique le titre provocateur “Attention Is All You Need”, la beauté de cette architecture, qui a abandonné les traitements récurrents et convolutifs complexes pour se spécialiser uniquement dans le calcul de “l’attention (degré de pertinence)”, réside véritablement dans sa simplicité mathématique.

À l’avenir, il est possible que de nouvelles architectures dépassant le Transformer (telles que Mamba, qui est un State Space Model) apparaissent, mais le cadre mathématique de “compréhension du contexte par Attention” construit par le Transformer restera à jamais gravé dans l’histoire de l’IA.

Si vous avez l’occasion d’utiliser des LLM comme ChatGPT ou Claude à l’avenir, essayez d’imaginer les billions de produits matriciels $Q K^T$ calculés chaque seconde en arrière-plan, et la fonction Softmax crachant des probabilités. Votre résolution de compréhension de la technologie augmentera, et vous trouverez probablement le monde de l’IA encore plus fascinant.

Références

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Cet article a été rédigé comme un guide pour ceux qui apprennent les bases mathématiques du traitement du langage naturel et de l’IA. Si vous avez des questions ou des discussions, n’hésitez pas à nous le faire savoir dans la section des commentaires !

Existe-t-il un algorithme surpassant GNFS (Crible général du corps de nombres) ?

Fri, 11 Sep 2026 09:00:00 +0900

1. Introduction : La factorisation d’entiers et le fondement de la cryptographie moderne

La sécurité des communications sur Internet dans la société moderne dépend fortement de la sécurité de la cryptographie à clé publique RSA. La sécurité de RSA repose sur l’hypothèse mathématique de la « difficulté de factoriser d’énormes nombres composés ». Si un algorithme de factorisation extrêmement efficace était découvert, l’infrastructure de communication mondiale s’effondrerait depuis ses fondations.

Actuellement, dans la factorisation d’entiers gigantesques à l’aide d’ordinateurs classiques, l’algorithme qui règne en tant que plus rapide et plus puissant est le Crible général du corps de nombres (GNFS : General Number Field Sieve). GNFS est né en tant qu’extension du crible spécial du corps de nombres (SNFS) proposé à la fin des années 1980, et jusqu’à aujourd’hui, il a établi des records de factorisation pour des nombres composés énormes tels que RSA-768 et RSA-250.

Cependant, les cryptographes et les mathématiciens se posent constamment les questions suivantes : « Existe-t-il un algorithme classique surpassant GNFS ? », « Où se situent les limites des ordinateurs classiques ? » et « Comment les ordinateurs quantiques vont-ils surmonter cette situation ? »

Cet article dissèque de manière approfondie la structure mathématique profonde derrière GNFS, et fournit une analyse technique détaillée de la sélection de polynômes, du processus de criblage et de l’étape d’algèbre linéaire via la méthode par blocs de Wiedemann. En outre, il examine les méthodes d’extension de GNFS, comme l’amélioration de Coppersmith, et compare et explique les différences cruciales entre les algorithmes classiques en temps sous-exponentiel (Sub-exponential time) et les algorithmes quantiques en temps polynomial d’un point de vue mathématique.

2. Complexité asymptotique et notation L (L-notation)

Lors de l’évaluation de la complexité des algorithmes de factorisation, au lieu de la notation standard en temps polynomial (comme $O(n^k)$), on utilise la notation L (L-notation) pour exprimer le temps sous-exponentiel par rapport au nombre de chiffres de l’entrée $n$. La notation L est définie comme suit :

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

Où $n$ est l’entier à factoriser, et $\ln n$ est le logarithme népérien, qui est proportionnel à la longueur en bits de $n$.

Lorsque $\alpha = 0$ : $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$, ce qui représente un temps polynomial (Polynomial time) par rapport à la longueur en bits.
Lorsque $\alpha = 1$ : $L_n[1, c] = \exp(c \ln n) = n^c$, ce qui représente un temps exponentiel (Exponential time) par rapport à la longueur en bits.
Lorsque $0 < \alpha < 1$ : Cela devient un temps sous-exponentiel (Sub-exponential time), situé entre le temps polynomial et le temps exponentiel.

L’histoire de l’évolution des algorithmes de factorisation du passé a également été l’histoire de la réduction progressive de la valeur de cet $\alpha$.

Méthode des fractions continues (CFRAC) et crible quadratique à polynômes multiples (MPQS) : Appartiennent à la classe $\alpha = 1/2$, avec une complexité d’environ $L_n[1/2, 1]$.
Crible général du corps de nombres (GNFS) : Atteint $\alpha = 1/3$, et s’enorgueillit de la complexité la plus rapide parmi les algorithmes classiques connus à ce jour, qui est de $L_n[1/3, (64/9)^{1/3}]$.

3. L’algorithme complet et la structure mathématique de GNFS

GNFS possède des fondations mathématiques extrêmement complexes et avancées. L’idée de base s’inscrit dans la continuité du petit théorème de Fermat et du crible quadratique (QS), qui consiste à trouver des paires non triviales $(X, Y)$ satisfaisant la congruence $X^2 \equiv Y^2 \pmod n$ et $X \not\equiv \pm Y \pmod n$, pour en déduire un facteur de $n$, $\gcd(X-Y, n)$.

Cependant, l’essence de GNFS réside dans le fait qu’il n’effectue pas cela uniquement dans le corps des nombres rationnels $\mathbb{Q}$, mais qu’il recherche simultanément des « nombres friables (Smooth numbers) » à la fois dans un corps d’extension $\mathbb{Q}(\alpha)$ appelé corps de nombres algébriques (Algebraic Number Field) et dans le corps des rationnels, et construit des relations de congruence par le biais d’homomorphismes.

Le processus de GNFS est divisé en 5 phases principales.

graph TD A["Problème de factorisation d'entiers (entrée n)"] --> B["1. Sélection de polynômes (Polynomial Selection)"] B --> C["2. Processus de criblage (Sieving Phase)"] C --> D["3. Filtrage (Filtering Phase)"] D --> E["4. Algèbre linéaire (Linear Algebra Phase)"] E --> F["5. Racine carrée (Square Root Phase)"] F --> G["Sortie des facteurs premiers p, q"]

3.1 Phase 1 : Sélection de polynômes (Polynomial Selection)

Le succès de GNFS dépend fortement de la sélection de polynômes appropriés. L’objectif est de trouver deux polynômes irréductibles ayant une racine commune $m$ : $f_1(x)$ (côté rationnel) et $f_2(x)$ (côté algébrique). C’est-à-dire qu’ils satisfont : $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$

Généralement, on choisit un polynôme de degré 1, $f_1(x) = x - m$, pour le côté rationnel, et un polynôme unitaire de degré $d$ (typiquement 5 ou 6) pour le polynôme côté algébrique $f_2(x)$. L’approche la plus classique est la méthode de la Base-$m$. On choisit un entier $m = \lfloor n^{1/(d+1)} \rfloor$ proche de la puissance $1/(d+1)$ de $n$, et on développe $n$ en base $m$. $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ On obtient ainsi le polynôme $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$. Évidemment, on a $f_2(m) = n \equiv 0 \pmod n$.

Cependant, dans les implémentations modernes, on utilise l’algorithme de Kleinjung. Celui-ci évite que les coefficients des polynômes ne deviennent trop grands (optimisation du Skewness) tout en optimisant les propriétés algébriques (valeur $E$ de Murphy et valeur $\alpha$), cherchant ainsi des polynômes susceptibles de générer facilement des nombres friables lors de la phase de criblage. Rien que pour cette étape, d’importantes ressources de calcul sont mobilisées.

3.2 Phase 2 : Processus de criblage (Sieving Phase)

Une fois les polynômes déterminés, l’algorithme entre dans la phase de « criblage (Sieving) », qui est la plus gourmande en calculs. Ici, on recherche des paires $(a, b)$. Ces paires doivent être premières entre elles, et il est requis que les deux valeurs suivantes soient simultanément « friables (Smooth) » :

Norme du côté rationnel : $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
Norme du côté algébrique : $F_2(a, b) = b^d \cdot f_2(a/b)$

« Friable » signifie qu’elles ne peuvent être factorisées qu’avec des nombres premiers inférieurs ou égaux à une limite spécifiée (Sieve bound). On prépare une base de facteurs (Factor base) pour le côté rationnel et une autre pour le côté algébrique, et on trouve efficacement les nombres friables sur un vaste espace de recherche à la manière du crible d’Ératosthène. Aujourd’hui, une méthode appelée crible par réseaux (Lattice Sieving) est dominante. En fixant un certain nombre premier $q$, et en ne criblant que les paires $(a, b)$ sur un sous-réseau où les côtés rationnel et algébrique sont tous deux des multiples de $q$, on atteint une efficacité extrêmement élevée.

3.3 Phase 3 : Filtrage (Filtering Phase)

Le nombre de relations (relations) friables trouvées lors du processus de criblage s’élève à des centaines de millions, voire des milliards. Cependant, celles-ci contiennent également beaucoup d’informations inutiles. Le but du filtrage est de construire une énorme matrice creuse (Sparse Matrix) tout en réduisant ses dimensions autant que possible.

Plus précisément, les opérations suivantes sont effectuées :

Suppression des singletons (Singleton removal) : Suppression des relations contenant un facteur premier qui n’apparaît qu’une seule fois.
Suppression/Fusion de cliques (Clique removal / Merging) : Multiplication entre elles de relations ayant des facteurs premiers apparaissant deux fois ou plus, afin d’éliminer des variables et de réduire à un système d’équations plus dense, mais de dimension plus petite.

Grâce à cela, une matrice de milliards de lignes est compressée en une énorme matrice creuse $\mathbf{A}$ de dizaines de millions de lignes (dont les éléments sont des 0 et des 1 sur le corps $\mathbb{F}_2$).

3.4 Phase 4 : Algèbre linéaire (Linear Algebra Phase)

Ici, on trouve un vecteur solution non trivial $\mathbf{x}$ de l’équation $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$. Autrement dit, c’est le problème de trouver l’espace nul à gauche (Left Nullspace) d’une énorme matrice creuse.

Étant donné que la taille de la matrice est extrêmement grande, il est absolument impossible de la calculer avec l’élimination de Gauss habituelle ($O(N^3)$). Par conséquent, des méthodes itératives, qui sont un type de méthode de sous-espace de Krylov, sont utilisées. Historiquement, la méthode par blocs de Lanczos (Block Lanczos) était utilisée, mais dans les environnements informatiques distribués actuels, la méthode par blocs de Wiedemann (Block Wiedemann Algorithm), qui permet de réduire considérablement la surcharge de communication, prédomine.

La méthode par blocs de Wiedemann calcule un polynôme minimal à partir de la matrice $\mathbf{A}$ et d’une séquence de vecteurs, et utilise l’algorithme de Berlekamp-Massey pour construire une base de l’espace nul. Cette étape est très difficile à paralléliser et constitue l’un des plus plus grands goulots d’étranglement de GNFS, exigeant des superordinateurs ou des réseaux de communication étroitement couplés de grands clusters.

3.5 Phase 5 : Racine carrée (Square Root Phase)

À partir des solutions de l’algèbre linéaire, on construit des produits qui sont des « carrés parfaits » pour chacun des côtés rationnel et algébrique. Du côté rationnel, $\prod (a-bm)$ devient le carré $X^2$ d’un certain entier $X$, et du côté algébrique, le produit des idéaux correspondants devient un carré parfait $\gamma^2$ sur le corps de nombres algébriques. En calculant ce $\gamma$ sur le corps de nombres algébriques et en appliquant l’homomorphisme $\phi: \alpha \mapsto m \pmod n$ vers l’anneau des entiers rationnels, on obtient la congruence : $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$

Pour calculer la racine carrée sur le corps de nombres algébriques, des algorithmes complexes tels que la méthode de Montgomery (Montgomery’s Method) sont utilisés, ce qui nécessite des connaissances approfondies en théorie algébrique des nombres. Enfin, en calculant $\gcd(X-Y, n)$, et si un facteur non trivial est obtenu, la factorisation est terminée.

4. Existe-t-il un algorithme classique surpassant GNFS ?

À ce jour, aucun algorithme classique avec une complexité asymptotique inférieure à $L_n[1/3, c]$ pour la factorisation d’entiers généraux n’a été découvert. Cependant, il existe plusieurs tentatives et algorithmes dérivés pour franchir les limites théoriques et pratiques.

4.1 Crible multiple du corps de nombres (MNFS: Multiple Number Field Sieve)

Comme approche étendant GNFS, on trouve le crible multiple du corps de nombres (MNFS) par D. Coppersmith. Alors que GNFS utilise deux polynômes (côté rationnel et côté algébrique), MNFS utilise simultanément plusieurs polynômes différents du côté algébrique pour un seul polynôme du côté rationnel.

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

En utilisant plusieurs corps algébriques, la probabilité de devenir « friable dans l’un des corps algébriques » à chaque étape de criblage peut être considérablement augmentée. Avec cette approche, Coppersmith a réussi à réduire légèrement la constante $c$ de la complexité $L_n[1/3, c]$. Concrètement, alors que la constante de GNFS est $c = (64/9)^{1/3} \approx 1.923$, il a été théoriquement démontré qu’en optimisant MNFS, la complexité pouvait être réduite à environ $c \approx 1.902$. Cependant, dans la pratique, la surcharge due à la gestion de corps multiples est importante, et cela n’a pas conduit à une percée décisive pour les modules RSA à l’échelle pratique.

4.2 Des algorithmes de la classe $L_n[1/4]$ sont-ils possibles ?

Concernant les limites des algorithmes classiques de factorisation d’entiers, un thème longuement débattu parmi les mathématiciens est la question : « Existe-t-il un algorithme d’exposant $\alpha = 1/4$ ? ». Le GNFS actuel et ses dérivés sont fortement liés au cadre de « recherche de friabilité » par le criblage, et il est largement admis qu’au sein de ce paradigme, $\alpha = 1/3$ est la limite. D’après l’analyse de la probabilité de distribution des entiers friables à l’aide de la fonction de Dickman, on pense qu’il est impossible de franchir le mur de $O(L_n[1/3])$, quelle que soit l’optimisation, avec la combinaison actuelle de construction de corps algébriques et de criblage.

S’il existait un algorithme en $L_n[1/4]$, ou même un algorithme classique en temps polynomial, il devrait dépendre d’une nouvelle structure mathématique totalement différente des approches basées sur la « friabilité » comme GNFS, et actuellement impensable pour l’humanité (par exemple, une approche de géométrie algébrique plus avancée comme l’algorithme de Schoof pour la cryptographie sur les courbes elliptiques). Cependant, il n’y a pour le moment aucun signe de cela.

5. La percée par les ordinateurs quantiques : l’algorithme de Shor

Alors que les ordinateurs classiques font face au mur du $L_n[1/3]$, c’est l’algorithme de Shor (Shor’s Algorithm), publié en 1994 par Peter Shor, qui a brisé ce mur en changeant fondamentalement le modèle de calcul lui-même.

5.1 Le choc du temps quantique polynomial

L’algorithme de Shor réduit le problème de la factorisation d’entiers au « problème de la recherche de l’ordre (Order Finding Problem) ». Pour un entier donné $a$, il s’agit de trouver la période (ordre) $r$ de la fonction $f(x) = a^x \pmod n$. Bien qu’un ordinateur classique nécessite un temps exponentiel pour trouver cette période, en utilisant l’estimation de phase quantique (QPE : Quantum Phase Estimation) et la transformée de Fourier quantique (QFT : Quantum Fourier Transform) sur un ordinateur quantique, il est possible d’évaluer en parallèle une superposition de tous les états (Superposition) et d’extraire la période $r$ avec une forte probabilité.

En termes de complexité, le temps d’exécution de l’algorithme de Shor est un temps quantique polynomial, plus précisément comme suit :

$$ O((\log n)^3) $$

Compte tenu des implémentations de circuits optimisées récentes, on considère que cela peut être réduit à $O((\log n)^2 \log \log n)$.

graph LR A["Algorithme classique (GNFS)"] -->|Limite| B["Temps sous-exponentiel L_n[1/3]"] C["Algorithme quantique (Shor)"] -->|Percée| D["Temps polynomial O((log n)^3)"] B --> E["Utilisation continue de RSA (augmentation de la longueur des clés)"] D --> F["Effondrement total de la cryptographie RSA"]

5.2 Temps sous-exponentiel classique vs Temps polynomial quantique

La différence entre ces deux classes de complexité a une signification décisive pour la sécurité cryptographique dans le monde réel.

Prenons l’exemple de la factorisation de RSA-2048 (un nombre composé de 2048 bits).

GNFS (Classique) : En substituant $n \approx 2^{2048}$ dans $L_n[1/3, 1.923]$, il faut environ $2^{112}$ opérations. Il s’agit d’une quantité astronomique de calculs qui prendrait plus de temps que l’âge de l’univers, même en rassemblant toutes les ressources informatiques actuelles sur Terre.
Algorithme de Shor (Quantique) : Avec un algorithme en $O((\log n)^3)$, il suffit d’environ $2048^3 \approx 8.5 \times 10^9$ opérations de portes logiques. Cela signifie que si le matériel approprié (un ordinateur quantique universel avec des millions de qubits physiques et des capacités de correction d’erreurs) existait, le calcul serait terminé en quelques heures à quelques jours seulement.

Le changement de paradigme passant d’une fonction sous-exponentielle avec un « exposant $\alpha=1/3$ » à un « temps polynomial » neutralise la stratégie traditionnelle de la cryptographie qui consiste à garantir la sécurité en augmentant la longueur de la clé.

6. Conclusion : Perspectives pour la prochaine génération

Le consensus actuel de la communauté scientifique concernant la question « Existe-t-il un algorithme classique surpassant GNFS ? » est le suivant :

Les améliorations pratiques se poursuivront, mais il n’y a pas de saut asymptotique : Les tentatives pour améliorer le terme constant $c$ de GNFS, telles que le MNFS, l’optimisation de la sélection de polynômes, ou la parallélisation de la méthode par blocs de Wiedemann, se poursuivent. Cependant, la probabilité de découvrir un algorithme classique descendant en dessous de $\alpha = 1/3$ est considérée comme extrêmement faible.
La sécurité de RSA sur les ordinateurs classiques reste forte : La complexité de GNFS reste énorme, et RSA-2048 ainsi que RSA-4096 continueront de maintenir leur sécurité contre les attaques par des ordinateurs classiques pour les décennies à venir.
La véritable menace vient des algorithmes quantiques : C’est l’algorithme de Shor, basé sur les principes de la mécanique quantique, qui a franchi le mur de la complexité computationnelle. De ce fait, le monde est contraint de faire la transition vers la cryptographie post-quantique (PQC : Post-Quantum Cryptography). La transition vers de nouveaux problèmes mathématiques considérés comme difficiles à résoudre (impossibles à résoudre en temps polynomial) même pour les ordinateurs quantiques, tels que la cryptographie sur les réseaux euclidiens ou la cryptographie basée sur les hachages, constitue la frontière actuelle de la cryptographie.

Le crible général du corps de nombres (GNFS) est l’un des « points culminants » atteints par l’humanité après avoir défié les limites des mathématiques classiques et de la conception d’algorithmes. Comprendre la structure mathématique profonde de GNFS n’est pas seulement apprendre l’histoire de la cryptanalyse, mais c’est aussi un voyage d’exploration intellectuelle touchant à la beauté de la théorie de la complexité algorithmique et de la théorie algébrique des nombres. Jusqu’au jour où les ordinateurs quantiques seront mis en pratique, GNFS continuera très probablement de défendre son trône de plus puissant algorithme de factorisation d’entiers.

Comment intégrer KaTeX dans Hugo et afficher de belles formules mathématiques de style LaTeX

Fri, 31 Mar 2023 23:11:26 +0900

Qu’est-ce que KaTeX

KaTeX est une bibliothèque javascript permettant d’afficher des formules mathématiques de style LaTeX en HTML.

Plus précisément, vous pouvez afficher des formules comme ci-dessous.

$$f(x) = x^2 + x + 41$$

Il semble y avoir d’autres bibliothèques d’affichage de formules de style LaTeX, mais KaTeX est réputé pour être simple et rapide.

Comment l’intégrer à hugo

Créez un nouveau layouts/partials/math.html dans la hiérarchie des dossiers de hugo.

Le contenu doit être le suivant.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css" integrity="sha384-vKruj+a13U8yHIkAyGgK1J3ArTLzrFGBbBc0tDp4ad/EyewESeXE/Iv67Aj8gKZ0" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js" integrity="sha384-PwRUT/YqbnEjkZO0zZxNqcxACrXe+j766U2amXcgMg5457rve2Y7I6ZJSm2A0mS4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(
 document.body,
 {
 delimiters: [
 {left: "$$", right: "$$", display: true},
 {left: "\\[", right: "\\]", display: true},
 {left: "$", right: "$", display: false},
 {left: "\\(", right: "\\)", display: false}
 ]
 });
 });
</script>

Ensuite, ajoutez le code ci-dessous au fichier existant layouts/partials/extend_head.html.

1
2
3


{{ if or .Params.math .Site.Params.math }}
{{ partial "math.html" . }}
{{ end }}

Vous êtes maintenant prêt à utiliser KaTeX.

Vous pouvez activer KaTeX en ajoutant math: true au front matter de la page.

Il ne vous reste plus qu’à écrire la formule dans le style LaTeX dans le corps de l’article de la page.

1

$$ e^{i \pi} = -1 $$

En l’écrivant comme ci-dessus, il s’affichera comme ci-dessous.

$$ e^{i \pi} = -1 $$