Les mathématiques
derrière l’IA

L’IA moderne, en particulier les grands modèles de langage, les générateurs d’images et les systèmes de classification, repose sur un socle mathématique étonnamment compact. Tout, de ChatGPT qui génère une phrase à Stable Diffusion qui produit une image, se ramène au niveau le plus bas aux mêmes opérations : multiplication matricielle, fonctions non linéaires et descente de gradient. La sophistication réside dans la manière dont ces primitives sont combinées et mises à l’échelle.

Cet article développe les mathématiques à partir des principes fondamentaux. Nous commençons par l’algèbre linéaire et la théorie des probabilités, passons par l’optimisation fondée sur le calcul différentiel, construisons le formalisme des réseaux de neurones, dérivons la rétropropagation et aboutissons au mécanisme d’attention et à l’architecture Transformer sur lesquels reposent tous les grands modèles de langage en 2026. Aucun raccourci n’est pris : chaque équation est dérivée ou expliquée à partir de ses composantes.

Prérequis : être à l’aise avec l’algèbre du lycée et les notations de base du calcul différentiel (dérivées, règle de dérivation en chaîne). Tout le reste est construit ici.

1.1 Vecteurs et espaces vectoriels

Un vecteur est une liste ordonnée de nombres. En IA, les vecteurs représentent tout : un mot, un fragment d’image, une préférence utilisateur, un état caché. Un vecteur x de l’espace réel à n dimensions s’écrit :

L’ensemble ℝⁿ est un espace vectoriel : il est stable par addition et par multiplication par un scalaire, possède un vecteur nul et satisfait les huit axiomes des espaces vectoriels. C’est cette structure algébrique qui rend l’algèbre linéaire applicable au machine learning : les couches d’un réseau de neurones sont des applications linéaires entre espaces vectoriels.

1.1.1 Le produit scalaire et la similarité cosinus

Le produit scalaire de deux vecteurs x, y ∈ ℝⁿ est :

où θ est l’angle entre les vecteurs. Le produit scalaire mesure l’alignement : il est maximal lorsque x et y pointent dans la même direction (cos θ = 1), nul lorsqu’ils sont orthogonaux (cos θ = 0) et minimal lorsqu’ils sont de sens opposés (cos θ = -1). Cette interprétation géométrique sous-tend les mécanismes d’attention : le produit scalaire entre une requête et une clé mesure à quel point elles « portent attention » l’une à l’autre.

La similarité cosinus normalise le produit scalaire par le produit des normes des vecteurs :

La similarité cosinus est très utilisée en NLP pour mesurer la similarité sémantique entre embeddings de mots : les vecteurs représentant des mots de sens proche se regroupent dans l’espace des embeddings et ont une similarité cosinus proche de 1.

1.2 Matrices et transformations linéaires

Une matrice W ∈ ℝᵐˣⁿ représente une transformation linéaire de ℝⁿ dans ℝᵐ. Produit matrice-vecteur :

C’est l’opération centrale d’une couche de réseau de neurones. Chaque ligne W_i· est un vecteur de poids ; la sortie y_i est le produit scalaire de la i-ème ligne avec l’entrée x. La matrice W encode ce que la couche a appris : quelles combinaisons linéaires des caractéristiques d’entrée calculer.

1.2.1 Multiplication matricielle

Pour des matrices A ∈ ℝᵐˣⁿ et B ∈ ℝⁿˣᵖ, leur produit C = AB ∈ ℝᵐˣᵖ a pour coefficients :

La multiplication matricielle n’est pas commutative (AB ≠ BA en général) mais elle est associative : A(BC) = (AB)C. Le coût de calcul de la multiplication d’une matrice m×n par une matrice n×p est O(mnp), le coût dominant dans les grands réseaux de neurones. Pour un Transformer de dimension cachée d = 4096 traitant une séquence de 2048 tokens, une seule multiplication matricielle coûte O(2048 × 4096 × 4096) ≈ 34 milliards d’opérations.

1.2.2 Transposée et matrices symétriques

La transposée W^ᵀ d’une matrice W échange lignes et colonnes : (W^ᵀ)_ij = W_ji. Propriétés clés : (AB)^ᵀ = B^ᵀA^ᵀ, (W^ᵀ)^ᵀ = W. Une matrice symétrique vérifie W = W^ᵀ.

Dans les Transformers, la matrice des poids d’attention QK^ᵀ/√d_k est calculée comme un produit matriciel faisant intervenir une transposée — la matrice des requêtes Q ∈ ℝˢˣᵈ multipliée par la transposée de la matrice des clés K^ᵀ ∈ ℝᵈˣˢ, ce qui produit une matrice de poids d’attention s×s, où s est la longueur de la séquence.

1.3 Valeurs propres, vecteurs propres et SVD

Un vecteur v est un vecteur propre de la matrice A si :

où λ est la valeur propre correspondante. Les vecteurs propres sont les directions que la matrice A étire ou contracte sans les faire tourner. L’ensemble des valeurs propres constitue le spectre de A ; il caractérise le comportement de la matrice : les grandes valeurs propres amplifient les directions correspondantes, les petites les atténuent.

La décomposition en valeurs singulières (SVD) généralise la décomposition spectrale aux matrices non carrées :

où U ∈ ℝᵐˣᵐ et V ∈ ℝⁿˣⁿ sont des matrices orthogonales (rotation/réflexion), et Σ ∈ ℝᵐˣⁿ est diagonale à coefficients positifs ou nuls σ₁ ≥ σ₂ ≥... ≥ σᵣ (les valeurs singulières). La SVD sert à la compression des poids : l’approximation de rang faible W_k = U_k Σ_k V_k^ᵀ, qui ne conserve que les k plus grandes valeurs singulières, fournit la meilleure approximation de rang k de W au sens de la norme de Frobenius — c’est le fondement du fine-tuning LoRA (Low-Rank Adaptation).

1.4 Normes et régularisation

La norme L2 (norme euclidienne) d’un vecteur x ∈ ℝⁿ :

La norme de Frobenius d’une matrice W ∈ ℝᵐˣⁿ :

Les normes quantifient la « taille » des vecteurs et des matrices. En optimisation, ajouter une pénalité de norme à la fonction de perte — la régularisation — pénalise les poids élevés et limite le surapprentissage. La régularisation L2 (weight decay) ajoute λ‖W‖²_F à la perte, ce qui fait décroître les poids vers zéro au fil de l’entraînement.

2.1 Distributions de probabilité

Une distribution de probabilité P sur un espace d’échantillonnage discret X associe P(x) ≥ 0 à chaque issue x ∈ X, avec Σ_x P(x) = 1. La modélisation du langage, c’est exactement cela : estimer une distribution sur des séquences de tokens.

Pour les variables continues, la densité de probabilité f(x) vérifie f(x) ≥ 0 et ∫f(x)dx = 1. La probabilité d’un intervalle est P(a ≤ X ≤ b) = ∫_a^b f(x)dx.

2.1.1 La distribution softmax

La fonction softmax convertit un vecteur de logits réels z ∈ ℝⁿ en distribution de probabilité :

Propriétés : toutes les sorties sont positives, leur somme vaut 1 (distribution de probabilité valide), et les logits élevés donnent des probabilités proches de 1 tandis que les logits faibles donnent des valeurs proches de 0. La mise à l’échelle par la température modifie ce comportement : softmax(z/T) tend vers l’argmax (one-hot) quand T → 0 et vers la distribution uniforme quand T → ∞. Les modèles de langage échantillonnent dans cette distribution à chaque étape de génération.

Le problème de stabilité numérique : exp(z) déborde pour les grandes valeurs de z. La solution classique consiste à soustraire le maximum avant l’exponentiation :

2.2 Théorie de l’information

2.2.1 Entropie de Shannon

L’entropie H(P) d’une distribution P mesure son incertitude, c’est-à-dire la quantité moyenne d’information d’une issue :

L’entropie est maximale lorsque P est uniforme (incertitude maximale) et minimale (= 0) lorsque P est déterministe. Une pièce équilibrée a H = 1 bit ; un dé à six faces a H = log₂(6) ≈ 2,58 bits. L’entropie d’une langue mesure le nombre de bits par token nécessaires pour l’encoder.

2.2.2 Entropie croisée et divergence KL

L’entropie croisée H(P, Q) mesure la longueur de code attendue lorsqu’on utilise la distribution Q pour encoder des échantillons issus de la vraie distribution P :

C’est la fonction de perte standard pour la classification et la modélisation du langage : P est la vraie distribution des étiquettes (one-hot), Q la distribution prédite par le modèle. Minimiser l’entropie croisée équivaut à maximiser la log-vraisemblance des données sous le modèle.

La divergence KL D_KL(P‖Q) mesure à quel point Q s’écarte de P :

La divergence KL est nulle si et seulement si P = Q presque partout, et strictement positive sinon (inégalité de Gibbs). Elle n’est pas symétrique : D_KL(P‖Q) ≠ D_KL(Q‖P). On la retrouve dans l’entraînement RLHF : le terme de pénalité KL qui empêche le modèle affiné de trop s’éloigner du modèle de base est D_KL(π_θ ‖ π_ref).

2.2.3 Perplexity

La perplexité est l’exponentielle de la perte d’entropie croisée ; c’est la métrique standard d’évaluation des modèles de langage :

Intuitivement, la perplexité correspond à la taille effective du vocabulaire parmi lequel le modèle choisit à chaque étape. Une perplexité de 20 signifie que le modèle est, en moyenne, aussi incertain que s’il choisissait uniformément parmi 20 options équiprobables. Les modèles de langage de pointe atteignent une perplexité de 3 à 8 sur les benchmarks standard.

2.3 Le théorème de Bayes

Le théorème de Bayes est le fondement du machine learning probabiliste :

où θ désigne les paramètres du modèle, D les données observées, P(θ|D) la loi a posteriori, P(D|θ) la vraisemblance, P(θ) la loi a priori et P(D) = ∫P(D|θ)P(θ)dθ la vraisemblance marginale (évidence). L’estimation du maximum de vraisemblance (MLE) maximise P(D|θ) en ignorant la loi a priori. L’estimation du maximum a posteriori (MAP) maximise P(θ|D), ce qui équivaut au MLE avec une régularisation proportionnelle à -log P(θ).

Le deep learning moderne recourt généralement au MLE/MAP plutôt qu’à une inférence bayésienne complète, car calculer la loi a posteriori sur des milliards de paramètres est inenvisageable en pratique. L’estimation de l’incertitude dans les LLM reste un problème de recherche ouvert.

3.1 Dérivées et gradient

La dérivée d’une fonction scalaire f : ℝ → ℝ au point x mesure le taux de variation instantané :

Pour une fonction f : ℝⁿ → ℝ (comme une fonction de perte), le gradient ∇f ∈ ℝⁿ est le vecteur des dérivées partielles :

Le gradient indique la direction de plus forte croissance. Se déplacer dans la direction opposée au gradient fait donc décroître la fonction de perte : c’est le principe de la descente de gradient.

3.1.1 La jacobienne et la hessienne

Pour une fonction vectorielle f : ℝⁿ → ℝᵐ, la matrice jacobienne J ∈ ℝᵐˣⁿ contient toutes les dérivées partielles du premier ordre : J_ij = ∂f_i/∂x_j. La jacobienne de la sortie d’une couche par rapport à son entrée est au cœur de la rétropropagation.

La matrice hessienne H ∈ ℝⁿˣⁿ d’une fonction scalaire contient toutes les dérivées partielles du second ordre : H_ij = ∂²f/(∂x_i ∂x_j). La hessienne caractérise la courbure du paysage de la perte : une hessienne définie positive indique un minimum local, une hessienne définie négative un maximum local, et une hessienne indéfinie un point selle.

3.1.2 La règle de dérivation en chaîne

La règle de dérivation en chaîne est le fondement mathématique de la rétropropagation. Pour des fonctions composées g(f(x)) :

Pour les fonctions vectorielles, la règle de dérivation en chaîne multivariée fait appel aux jacobiennes :

Un réseau de neurones est une composition de fonctions : L(θ) = loss(fₙ(...f₂(f₁(x; W₁)); Wₙ)). La règle de dérivation en chaîne, appliquée récursivement à cette composition, calcule ∂L/∂W_i pour chaque couche i — cette application récursive, c’est la rétropropagation.

3.2 La descente de gradient et ses variantes

3.2.1 Descente de gradient stochastique

La descente de gradient classique met à jour les paramètres θ dans la direction opposée au gradient :

où η est le taux d’apprentissage. Calculer le vrai gradient sur l’ensemble du jeu de données est coûteux : O(N) passes avant par étape. La descente de gradient stochastique (SGD) l’approxime à l’aide d’un mini-lot B ⊂ D de taille b :

Le gradient du mini-lot est un estimateur sans biais du gradient complet : E[g_B] = ∇L. Sa variance diminue avec la taille du lot b : Var(g_B) = σ²/b.

3.2.2 Momentum

Le momentum accumule un vecteur vitesse v dans la direction des composantes persistantes du gradient :

Avec β ∈ [0,9 ; 0,99], le momentum fait en pratique la moyenne des gradients sur 1/(1-β) étapes : 10 étapes pour β = 0,9 et 100 étapes pour β = 0,99. Cela accélère la convergence le long des dimensions plates et amortit les oscillations le long des dimensions abruptes.

3.2.3 Adam : estimation adaptative des moments

Adam (Kingma & Ba, 2015) maintient des taux d’apprentissage adaptatifs propres à chaque paramètre en suivant à la fois le premier moment (moyenne) et le second moment (variance non centrée) des gradients :

Hyperparamètres typiques : β₁ = 0,9, β₂ = 0,999, ε = 10⁻⁸, η = 3×10⁻⁴. Le taux d’apprentissage effectif de chaque paramètre est η/√v̂_t : les paramètres dont le gradient a une forte variance font des pas effectifs plus petits, ceux dont le gradient varie peu font des pas plus grands.

3.2.4 Planification du taux d’apprentissage

Le taux d’apprentissage η n’est généralement pas maintenu constant. Parmi les planifications courantes figurent le warmup linéaire suivi d’une décroissance cosinus (utilisé dans la plupart des préentraînements de Transformers), le recuit cosinus avec redémarrages et la décroissance polynomiale. La phase de warmup est cruciale pour les grands modèles : à l’initialisation, les estimations du gradient sont bruitées et un taux d’apprentissage initial élevé peut déstabiliser l’entraînement.

4.1 La couche feedforward

Une couche de réseau de neurones calcule une transformation linéaire suivie d’une fonction d’activation non linéaire σ :

où W ∈ ℝᵐˣⁿ est la matrice de poids, b ∈ ℝᵐ le vecteur de biais, x ∈ ℝⁿ l’entrée et h ∈ ℝᵐ l’état caché. Sans σ, empiler des couches reviendrait à une seule transformation linéaire. La fonction d’activation rompt cette linéarité et permet aux réseaux profonds de représenter des fonctions exponentiellement plus complexes.

4.2 Fonctions d’activation

4.2.1 ReLU et ses variantes

Propriétés : calcul trivial, gradient égal à 0 (x < 0) ou à 1 (x > 0), activations creuses, pas de saturation pour les valeurs positives. Problème : le « dying ReLU » — les neurones pour lesquels x < 0 ont un gradient nul et ne peuvent plus se rétablir.

GeLU (Gaussian Error Linear Unit), utilisée dans GPT et BERT :

SwiGLU, utilisée dans LLaMA/PaLM, en est une variante à porte :

4.2.2 Sigmoïde et tangente hyperbolique

Toutes deux souffrent de la disparition du gradient dans les réseaux profonds : pour |x| >> 0, le gradient σ'(x) = σ(x)(1-σ(x)) → 0, si bien que les gradients s’évanouissent exponentiellement en se propageant vers l’arrière. C’était le principal obstacle à l’entraînement des réseaux profonds avant ReLU et les connexions résiduelles.

4.3 Perceptrons multicouches (MLP)

Un MLP à L couches calcule :

Le théorème d’approximation universelle (Hornik, 1989) établit qu’un MLP à une seule couche cachée suffisamment large peut approcher n’importe quelle fonction continue sur un domaine compact avec une précision arbitraire. Cependant, pour de nombreuses classes de fonctions, les réseaux profonds sont exponentiellement plus économes en paramètres que les réseaux peu profonds.

4.4 Rétropropagation

La rétropropagation calcule ∂L/∂W pour chaque matrice de poids W d’un réseau de neurones, en appliquant la règle de dérivation en chaîne à rebours à travers le graphe de calcul.

Définissons les signaux d’erreur (gradients amont) :

La récurrence de la rétropropagation :

# Forward pass
def forward(x, layers):
    activations = [x]
    pre_activations = []
    for W, b in layers:
        z = W @ activations[-1] + b
        pre_activations.append(z)
        activations.append(relu(z))
    return activations, pre_activations

# Backward pass
def backward(loss_grad, activations, pre_acts, layers):
    delta = loss_grad
    grads = []
    for l in reversed(range(len(layers))):
        W, b = layers[l]
        dW = delta @ activations[l].T  # ∂L/∂W
        db = delta.sum(axis=1)         # ∂L/∂b
        grads.insert(0, (dW, db))
        if l > 0:
            delta = (W.T @ delta) * relu_grad(pre_acts[l-1])
    return grads

4.5 Le problème de la disparition et de l’explosion du gradient

Le signal d’erreur δₗ fait intervenir un produit de L-l matrices jacobiennes. Si le rayon spectral ρ(J) < 1, les gradients s’évanouissent exponentiellement. Si ρ(J) > 1, ils explosent. Parmi les solutions : les connexions résiduelles (h = F(x) + x), l’écrêtage du gradient (‖g‖ > γ → remise à l’échelle), la normalisation de couche et une initialisation soignée (initialisation de He : W ~ N(0, 2/n_in)).

5.1 Normalisation par lots (Batch Normalization)

γ et β sont des paramètres appris qui permettent au réseau d’annuler la normalisation si c’est optimal. La BatchNorm pose problème pour les modèles de langage, car les séquences sont de longueur variable et les statistiques de lot sont instables pour les petits lots.

5.2 Normalisation de couche (Layer Normalization)

Les statistiques de la normalisation de couche sont calculées par exemple et non par lot : elles ne dépendent pas de la taille du lot et fonctionnent de la même façon à l’entraînement et à l’inférence. C’est pourquoi la LayerNorm est la normalisation standard des Transformers. Dans les Transformers Pre-LN (GPT-2 et suivants), la LayerNorm est appliquée avant les sous-couches d’attention et MLP, ce qui rend la dynamique d’entraînement plus stable à grande échelle.

5.3 RMSNorm

RMSNorm est environ 10 % plus rapide que LayerNorm pour des résultats comparables. Elle est utilisée dans les architectures LLaMA, Mistral et Gemma. L’intuition : l’étape de recentrage de LayerNorm a un effet minime sur la qualité du modèle ; le bénéfice principal vient de la remise à l’échelle, qui contrôle l’amplitude des activations.

6.1 Embeddings de tokens

Une matrice d’embeddings de tokens E ∈ ℝ^|V|×d associe à chaque token discret du vocabulaire V un vecteur dense de dimension d :

La dimension d’embedding d est généralement comprise entre 512 et 4096 pour les modèles modernes. La matrice d’embeddings est apprise conjointement avec le reste du modèle : les tokens proches dans l’espace des embeddings ont des usages contextuels similaires. La découverte, avec Word2Vec, que l’arithmétique dans l’espace des embeddings capture des relations sémantiques (roi - homme + femme ≈ reine) est une propriété émergente de l’entraînement sur de grands corpus.

Partage des poids (weight tying) : dans de nombreux modèles, la matrice de projection de sortie W_out est partagée avec E^ᵀ, ce qui réduit le nombre de paramètres de |V|×d sans dégradation constatée empiriquement.

6.2 Encodage positionnel

Les Transformers n’ont pas de notion d’ordre intrinsèque : l’attention est équivariante par permutation. L’encodage positionnel injecte l’information de position.

6.2.1 Encodage positionnel sinusoïdal

6.2.2 Embeddings de position rotatifs (RoPE)

RoPE (Su et al., 2021), utilisé dans LLaMA, Mistral et GPT-NeoX, encode la position en faisant tourner les vecteurs de requête et de clé dans des sous-espaces 2D :

Le produit scalaire ne dépend que de la position relative m-n, et non des positions absolues. RoPE est ainsi strictement supérieur à l’encodage sinusoïdal en matière de sensibilité à la position relative, et il permet d’extrapoler la longueur de contexte.

7.1 Attention par produit scalaire normalisé

Le mécanisme d’attention calcule des sommes pondérées de valeurs, les poids étant déterminés par la similarité entre requêtes et clés :

où Q ∈ ℝˢˣᵈᵏ (requêtes), K ∈ ℝˢˣᵈᵏ (clés), V ∈ ℝˢˣᵈᵥ (valeurs). Le facteur d’échelle 1/√d_k empêche les produits scalaires de devenir trop grands — sans lui, la softmax sature en distributions quasi one-hot, ce qui fait disparaître les gradients.

Dans la matrice des poids d’attention A = softmax(QK^ᵀ/√d_k) ∈ ℝˢˣˢ, le coefficient A_ij représente l’attention que la position i porte à la position j. La sortie est une somme pondérée de valeurs : output_i = Σ_j A_ij V_j. Chaque position peut ainsi agréger l’information de n’importe quelle autre position de la séquence — la capacité qui définit les Transformers.

7.2 Attention multi-têtes

L’attention multi-têtes exécute h opérations d’attention en parallèle dans des sous-espaces de dimension inférieure :

Les différentes têtes apprennent des motifs d’attention différents : certaines se concentrent sur les positions récentes (contexte local), d’autres sur la structure syntaxique, d’autres encore sur les relations sémantiques. Avec h = 12 têtes et d = 768 (BERT-base), chaque tête opère dans un sous-espace de dimension 64.

7.3 Attention causale (masquée)

Ajouter -∞ aux positions masquées avant la softmax donne exp(-∞) = 0, ce qui annule les poids d’attention correspondants. L’attention obtenue est triangulaire inférieure : la position i porte attention aux positions 1,...,i mais pas à i+1,...,s.

7.4 Complexité algorithmique

L’attention standard est en O(s²d) en temps et en O(s²) en mémoire, à cause de la matrice d’attention s×s. Parmi les variantes efficaces : FlashAttention (découpage en tuiles pour une accélération de 2 à 4×, résultat exact), l’attention creuse (O(s·w) pour une taille de fenêtre w), l’attention linéaire (O(s·d²)) et la Multi-Query Attention (K et V partagés entre les têtes, ce qui divise la taille du cache KV par h).

8.1 Le bloc Transformer

Une couche Transformer se compose de deux sous-couches, l’auto-attention multi-têtes et un MLP appliqué position par position, chacune dotée d’une connexion résiduelle et d’une normalisation de couche :

La sous-couche MLP :

où W₁ ∈ ℝ^4d×d et W₂ ∈ ℝ^d×4d. Pour d = 4096, ce MLP compte environ 134 millions de paramètres par couche.

8.2 Nombre de paramètres

Pour GPT-3 (L = 96, d = 12288) : 12 × 96 × 12288² ≈ 175 milliards de paramètres.

8.3 Le flux résiduel

Le schéma des connexions résiduelles crée le flux résiduel (residual stream) : un vecteur de dimension d qui traverse tout le réseau et que chaque couche modifie de façon additive :

L’interprétabilité mécaniste considère le flux résiduel comme un canal de communication : les têtes d’attention et les couches MLP y lisent et y écrivent des mises à jour additives, ce qui permet d’étudier la circulation de l’information.

9.1 Le paysage de la perte

La fonction de perte d’un réseau de neurones L : ℝⁿ → ℝ (où n ~ 10⁹–10¹²) est fortement non convexe. Théoriquement insoluble, elle n’empêche pourtant pas les grands réseaux surparamétrés d’être relativement faciles à entraîner, grâce à la surparamétrisation (la plupart des minima locaux sont proches du minimum global), au régime NTK (les réseaux de largeur infinie convergent comme une régression à noyau) et à la régularisation implicite (la SGD trouve des minima plats qui généralisent bien).

9.2 Les lois d’échelle de Chinchilla

Hoffmann et al. (2022) ont établi des lois d’échelle empiriques reliant le budget de calcul C, la taille du modèle N et la taille du jeu de données D :

où E ≈ 1,69 (entropie irréductible), α ≈ β ≈ 0,34. Le résultat clé : pour un calcul fixe C = 6ND, le compromis optimal est N_opt ∝ C^0.5 et D_opt ∝ C^0.5 — la taille du modèle et celle du jeu de données doivent croître dans les mêmes proportions. Il en découle que GPT-3 (175 milliards de paramètres, 300 milliards de tokens) était nettement sous-entraîné.

9.3 Entraînement en précision mixte

Les modèles modernes s’entraînent en précision mixte : passe avant en float16 pour économiser la mémoire, mises à jour des poids en float32 pour la stabilité numérique.

# Forward pass in fp16
with torch.autocast(device_type='cuda', dtype=torch.float16):
    logits = model(input_ids)
    loss = cross_entropy(logits, targets)

# Backward pass: gradients in fp16
scaler.scale(loss).backward()

# Gradient unscaling + clipping in fp32
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# Weight update in fp32 (master weights)
scaler.step(optimizer)
scaler.update()

Le BFloat16 est préféré au float16 : il a le même exposant sur 8 bits que le float32 (même plage dynamique), mais seulement 7 bits de mantisse, ce qui évite les dépassements de capacité vers le haut ou vers le bas sans mise à l’échelle de la perte.

9.4 Entraînement distribué

Entraîner un modèle de 70B exige environ 140 Go de mémoire GPU rien que pour les poids. Les stratégies comprennent le parallélisme de données (répliquer le modèle, synchroniser les gradients), le parallélisme de tenseurs (répartir les matrices de poids entre GPU), le parallélisme de pipeline (attribuer les couches à différents GPU) et ZeRO (partitionner les états de l’optimiseur, les gradients et les poids entre les workers, ce qui permet des modèles de taille arbitraire).

10.1 L’objectif autorégressif

À chaque position t, le modèle prédit une distribution sur l’ensemble du vocabulaire V à partir de tous les tokens précédents. Cet objectif simple de prédiction du token suivant, appliqué à une échelle colossale, suffit pour apprendre des représentations riches du langage, des connaissances factuelles et des capacités de raisonnement.

10.2 Stratégies de décodage

10.2.1 Mise à l’échelle par la température

T < 1 accentue la distribution (plus déterministe), T > 1 l’aplatit (plus aléatoire). T = 0 revient à l’argmax (décodage glouton).

10.2.2 Échantillonnage top-k

10.2.3 Échantillonnage nucleus (top-p)

Le top-p est adaptatif : plus de tokens en cas d’incertitude, moins lorsque le modèle est confiant. Réglages typiques : température de 0,7 à 1,0, top-p de 0,9 à 0,95.

10.2.4 Recherche en faisceau (beam search)

La recherche en faisceau maximise directement la probabilité. Elle est privilégiée pour la traduction et les sorties structurées ; l’échantillonnage est préféré pour la génération ouverte.

10.3 Le cache clé-valeur

Pendant l’inférence autorégressive, le cache KV stocke les tenseurs K et V déjà calculés, ce qui ramène chaque étape de génération à O(sd) au lieu de O(s²d), mais consomme O(2Lsd) de mémoire, soit environ 320 Go en float16 pour un modèle de 70B. La compression du cache KV est un domaine de recherche actif, essentiel pour l’inférence en contexte long.

kv_cache = {}

def generate_step(input_token, kv_cache, model):
    q, k, v = model.qkv_proj(embed(input_token))

    if layer_idx in kv_cache:
        K = torch.cat([kv_cache[layer_idx][0], k], dim=1)
        V = torch.cat([kv_cache[layer_idx][1], v], dim=1)
    else:
        K, V = k, v

    kv_cache[layer_idx] = (K, V)
    output = scaled_dot_product_attention(q, K, V)
    return output, kv_cache

11.1 Le pipeline en trois étapes

Le RLHF aligne les modèles de langage préentraînés sur les préférences humaines en trois étapes : fine-tuning supervisé (SFT), entraînement du modèle de récompense et optimisation par apprentissage par renforcement.

11.2 Le modèle de récompense

Un modèle de récompense R_φ : (prompt, complétion) → ℝ est entraîné sur des données de préférences humaines par paires :

11.3 Optimisation par PPO

Le modèle de langage π_θ est optimisé pour maximiser la récompense attendue tout en restant proche de la politique de référence :

Le terme KL empêche le reward hacking, c’est-à-dire que le modèle dérive pour exploiter les faiblesses du modèle de récompense. L’objectif de substitution écrêté de PPO empêche des mises à jour de politique trop importantes, qui déstabiliseraient l’entraînement.

11.4 Direct Preference Optimization (DPO)

La DPO (Rafailov et al., 2023) se passe entièrement du modèle de récompense :

La DPO est mathématiquement équivalente au RLHF, mais plus simple, plus stable, et ne nécessite pas de modèle de récompense distinct. La plupart des pipelines de fine-tuning modernes utilisent la DPO ou ses variantes (IPO, KTO) plutôt que PPO.