Un modèle de langue
ne fait qu'une seule chose.

Avant toute architecture, il y a une décomposition élémentaire de la théorie des probabilités. Elle explique pourquoi la génération de texte se ramène à une boucle de prédiction, et pourquoi cette boucle suffit.

0.1 — La règle de la chaîne

Soit une séquence de jetons \(x = (x_1,\dots,x_T)\), chacun pris dans un vocabulaire fini \(V\). La probabilité jointe de la séquence se factorise exactement, sans approximation ni hypothèse, en un produit de conditionnelles :

C'est une identité, pas un modèle. Ce qui en fait un programme de recherche, c'est le remplacement de la vraie conditionnelle \(p\) — inconnue — par une famille paramétrée \(p_\theta\) que l'on peut évaluer et différentier. Un « grand modèle de langue » est exactement cela : un choix de \(p_\theta\), plus une procédure pour ajuster \(\theta\).

Deux conséquences immédiates, souvent mal comprises :

• La génération est un sous-produit. Si l'on sait évaluer \(p_\theta(\cdot\mid x_{<t})\), on sait générer : on tire \(x_t\), on l'ajoute au contexte, on recommence. C'est l'échantillonnage ancestral. Le modèle n'a jamais été entraîné à « écrire un texte » ; il a été entraîné à prédire le jeton suivant, et l'écriture en découle.
• L'objet appris est une densité, pas une base de connaissances. Le modèle n'optimise aucun critère de vérité. Il optimise la vraisemblance d'un corpus. Toute la §10 découle de cette phrase.

0.2 — Conventions de notation

Sauf mention contraire, les vecteurs sont des lignes et les matrices de poids multiplient à droite : \(y = xW\). Cette convention, celle du code réel (PyTorch, JAX), évite les transpositions parasites. Les logarithmes sont naturels ; les pertes sont donc en nats, et l'on divise par \(\ln 2\) pour obtenir des bits.

Aucune magie ici : l'apprentissage profond est un cas particulier de la minimisation du risque empirique, avec une famille de fonctions très expressive et un optimiseur du premier ordre.

1.1 — Risque, risque empirique, et le fossé entre les deux

On postule une distribution inconnue \(\mathcal{D}\) sur les données. L'objet que l'on voudrait minimiser est le risque, c'est-à-dire la perte moyenne sur cette distribution :

Il est inaccessible : on ne dispose que d'un échantillon \(\{x^{(1)},\dots,x^{(n)}\}\). On minimise donc le risque empirique \(\hat{\mathcal{R}}(\theta) = \frac1n\sum_i \ell(\theta;x^{(i)})\). Toute la théorie de l'apprentissage porte sur l'écart \(\mathcal{R} - \hat{\mathcal{R}}\), l'erreur de généralisation.

Le point important, et sous-estimé : pour les grands modèles de langue entraînés sur un corpus web à passe unique, cet écart est petit par construction. Chaque exemple n'est vu qu'une fois ou presque ; le risque empirique mesuré au fil de l'entraînement est déjà une estimation quasi non biaisée du risque. C'est une situation très différente de celle du régime classique « peu de données, plusieurs époques », et cela explique pourquoi la régularisation explicite (dropout, weight decay agressif) joue un rôle mineur dans le pré-entraînement moderne.

1.2 — La perte : entropie croisée, et rien d'autre

La perte de pré-entraînement est la log-vraisemblance négative moyenne, autrement dit l'entropie croisée entre la distribution empirique des jetons et celle du modèle :

Trois lectures équivalentes de la même quantité, qu'il faut avoir simultanément en tête :

• Statistique — c'est l'estimateur du maximum de vraisemblance. Minimiser (3) revient à maximiser la probabilité que le modèle assigne au corpus observé.
• Théorie de l'information — \(\mathcal{L}/\ln 2\) est le nombre moyen de bits nécessaires pour coder le prochain jeton avec le modèle comme code. Un modèle de langue est un compresseur : associé à un codeur arithmétique, il compresse le texte à exactement \(\mathcal{L}/\ln2\) bits par jeton. Améliorer le modèle, c'est compresser mieux.
• Divergence — \(\mathcal{L} = H(p^\star) + D_{\mathrm{KL}}(p^\star \,\|\, p_\theta)\). Le premier terme est l'entropie intrinsèque du langage : irréductible, indépendante de \(\theta\). Seule la KL est optimisable. C'est la raison profonde pour laquelle les lois d'échelle (§5.5) comportent un terme constant \(E\) que l'on ne franchira jamais.

La perplexité n'est qu'une réécriture exponentielle, choisie pour être interprétable comme « nombre effectif de choix équiprobables » :

1.3 — Généralisation : le régime moderne ne ressemble pas au manuel

Le compromis biais–variance classique prédit une courbe en U : au-delà d'une certaine capacité, l'erreur de test doit remonter. Les réseaux profonds surparamétrés violent cette prédiction de manière reproductible.

Double descente — l'erreur de test remonte au voisinage du seuil d'interpolation (là où le modèle a juste assez de capacité pour mémoriser l'ensemble d'entraînement), puis redescend lorsqu'on continue d'augmenter la capacité [1]. Le même phénomène s'observe en fonction du nombre d'époques et de la taille des données. Cela invalide l'usage naïf du principe de parcimonie comme guide de conception.

Grokking — sur certaines tâches algorithmiques, un réseau atteint 100 % en entraînement très tôt et reste au niveau du hasard en test pendant des ordres de grandeur d'itérations, avant de basculer brutalement vers la généralisation parfaite [2]. La mémorisation et la généralisation sont donc des phases distinctes, séparées dans le temps d'optimisation.

Il n'existe à ce jour aucune théorie de la généralisation qui prédise quantitativement ces comportements pour des réseaux à l'échelle réelle. Les bornes classiques (VC, Rademacher, PAC-bayésiennes) sont vides ou vacillantes dans ce régime. C'est une lacune théorique majeure, et il faut la nommer comme telle.

1.4 — Représenter n'est pas apprendre

Le théorème d'approximation universelle (Cybenko 1989 ; Hornik 1991 [3,4]) énonce qu'un réseau à une seule couche cachée, de largeur suffisante et à activation non polynomiale, approche uniformément toute fonction continue sur un compact. On le cite souvent comme justification de la puissance des réseaux. C'est un contresens : le théorème est existentiel et n'affirme rien sur

• la largeur requise — elle peut être exponentielle en la dimension d'entrée ;
• l'accessibilité de ces poids par descente de gradient ;
• la quantité de données nécessaire pour les identifier ;
• la généralisation hors du compact considéré.

Ce qui rend les architectures profondes utiles n'est donc pas leur universalité — les polynômes sont universels aussi — mais le fait que la classe de fonctions qu'elles rendent faciles à atteindre par gradient recoupe la classe des fonctions utiles sur des données naturelles. Cette adéquation reste empirique.

Une composition de fonctions différentiables, un calcul de dérivée en mode inverse, et une règle de mise à jour. Trois idées, dont deux datent des années 1980.

2.1 — La brique : couche affine et non-linéarité

Le perceptron multicouche empile des transformations de la forme \(h^{(\ell+1)} = \phi\big(h^{(\ell)}W^{(\ell)} + b^{(\ell)}\big)\). Sans la non-linéarité \(\phi\), la composition de couches affines reste affine : la profondeur n'apporterait rien. \(\phi\) est donc ce qui rend l'empilement non trivial.

Le bloc de rétroaction (« feed-forward ») d'un Transformer moderne utilise SwiGLU, ce qui impose trois matrices (porte, montée, descente) au lieu de deux. À budget de paramètres constant, on compense en réduisant la dimension cachée d'un facteur \(2/3\) : \(d_{\text{ff}} \approx \tfrac{8}{3}d\) au lieu de \(4d\).

2.2 — Rétropropagation : la règle de la chaîne en mode inverse

Soit \(\mathcal{L}\) scalaire, obtenue par composition \(x \to h^{(1)} \to \dots \to h^{(L)} \to \mathcal{L}\). La différentiation automatique en mode inverse propage les sensibilités de la sortie vers l'entrée :

Pourquoi le mode inverse et pas direct ? Parce que le coût de la différentiation automatique dépend du rapport entre nombre d'entrées et nombre de sorties. Pour une fonction \(\mathbb{R}^N \to \mathbb{R}\) — exactement notre cas, \(N\) paramètres vers une perte scalaire — le mode inverse obtient toutes les dérivées partielles en un seul balayage, à un coût d'environ deux fois la passe avant. Le mode direct exigerait \(N\) balayages. Sur \(N = 10^{11}\), l'écart est décisif.

D'où la comptabilité de FLOP universellement utilisée : par jeton et par paramètre, la passe avant coûte 2 FLOP (une multiplication, une addition), la passe arrière environ 4 (gradient par rapport aux entrées, plus gradient par rapport aux poids). Soit 6 FLOP par paramètre et par jeton à l'entraînement, 2 à l'inférence — l'équation (17) de la §5.4.

Le prix de cette efficacité est la mémoire : la passe arrière a besoin des activations de la passe avant. Un modèle de 70 milliards de paramètres avec un lot de plusieurs milliers de jetons stocke des centaines de gigaoctets d'activations. Les parades sont le gradient checkpointing (on ne garde qu'une activation sur \(\sqrt{L}\) et on recalcule le reste : mémoire en \(O(\sqrt{L})\), coût en temps +33 %) et le parallélisme de séquence (§5.3).

2.3 — Stabiliser la profondeur : résidus, normalisation, initialisation

Empiler naïvement 100 couches ne fonctionne pas : le gradient s'évanouit ou explose de façon multiplicative. Trois dispositifs, tous indispensables :

Connexions résiduelles [7] — on écrit \(h^{(\ell+1)} = h^{(\ell)} + f(h^{(\ell)})\). La jacobienne devient \(I + \partial f\) : le chemin identité garantit un gradient de norme au moins 1 quel que soit le nombre de couches. C'est ce qui rend la profondeur exploitable. On appelle « residual stream » le vecteur \(h^{(\ell)}\) qui traverse tout le réseau : chaque bloc y ajoute sa contribution plutôt que de le remplacer, ce qui a des conséquences interprétatives majeures (§9).

Normalisation — LayerNorm [8] recentre et réduit chaque vecteur d'activation sur sa dimension de canal. RMSNorm [9] supprime le recentrage, ne gardant que la mise à l'échelle :

RMSNorm coûte moins cher et n'entraîne aucune perte de qualité mesurable ; c'est le choix standard depuis Llama. Le placement compte davantage que la formule : en pré-norme (\(h + f(\mathrm{Norm}(h))\)), le chemin résiduel reste propre et l'entraînement est stable sans échauffement délicat ; en post-norme (la formulation originale de 2017), il faut un échauffement du taux d'apprentissage soigneusement réglé sous peine de divergence [10]. Tous les grands modèles actuels sont en pré-norme.

Initialisation — les poids sont tirés de sorte que la variance des activations se conserve d'une couche à l'autre. Pour une couche de largeur \(n_{\text{in}}\) avec ReLU, l'initialisation de He tire \(W_{ij}\sim\mathcal{N}(0, 2/n_{\text{in}})\). Dans les Transformers, les projections de sortie des blocs sont en outre réduites d'un facteur \(1/\sqrt{2L}\) pour que la variance du flux résiduel ne croisse pas linéairement avec la profondeur.

2.4 — Optimiseurs : pourquoi Adam plutôt que la descente de gradient

La descente de gradient stochastique met à jour \(\theta \leftarrow \theta - \eta \nabla\hat{\mathcal{R}}\). Sur un objectif quadratique de matrice hessienne \(H\) à valeurs propres \(\lambda_{\min}\dots\lambda_{\max}\), elle ne converge que si \(\eta < 2/\lambda_{\max}\), et sa vitesse est gouvernée par le conditionnement \(\kappa = \lambda_{\max}/\lambda_{\min}\) : le nombre d'itérations pour atteindre une précision donnée croît proportionnellement à \(\kappa\). Les pertes des réseaux profonds ont un conditionnement épouvantable — plusieurs ordres de grandeur.

Adam [11] contourne le problème en normalisant chaque coordonnée par une estimation de l'amplitude locale de son gradient :

Le rapport \(\hat m/\sqrt{\hat v}\) est sans dimension : le pas effectif est de l'ordre de \(\eta\) pour chaque coordonnée, indépendamment de l'échelle de son gradient. C'est un préconditionnement diagonal, une approximation très grossière de la méthode de Newton — mais suffisante pour changer le régime d'entraînement. Réglages usuels : \(\beta_1=0{,}9\), \(\beta_2=0{,}95\) (plus court que le 0,999 par défaut, pour les gros lots), \(\epsilon=10^{-8}\).

AdamW [12] corrige une erreur conceptuelle : dans Adam, ajouter \(\lambda\|\theta\|^2\) à la perte fait passer la pénalité par le préconditionneur, ce qui la déforme. AdamW la découple : \(\theta_t = \theta_{t-1} - \eta(\hat m_t/(\sqrt{\hat v_t}+\epsilon) + \lambda\theta_{t-1})\). C'est la variante universellement employée.

Le coût est mémoire : deux moments par paramètre. En précision mixte, la comptabilité standard est de 16 octets par paramètre (4 poids maîtres fp32 + 4 pour \(m\) + 4 pour \(v\) + 2 poids bf16 + 2 gradients bf16), soit 1,1 To pour un modèle de 70 milliards de paramètres — avant même de compter les activations. D'où les stratégies de partitionnement d'état (ZeRO, §5.3).

Calendrier du taux d'apprentissage — l'usage converge sur : échauffement linéaire sur quelques milliers de pas (pour laisser \(\hat v\) se stabiliser avant de faire de grands pas), puis décroissance en cosinus jusqu'à environ 10 % de la valeur maximale. Le taux maximal se règle empiriquement et décroît lorsque la taille du modèle augmente.

Un réseau ne manipule que des nombres réels. Entre le fichier UTF-8 et la première multiplication matricielle, il y a deux conversions, et chacune impose des contraintes durables au modèle.

3.1 — Tokenisation : le compromis entre le caractère et le mot

Deux extrêmes sont possibles et tous deux mauvais. Un vocabulaire de caractères (ou d'octets) est petit et couvre tout, mais allonge les séquences d'un facteur 4 à 5 — or le coût de l'attention est quadratique en longueur. Un vocabulaire de mots raccourcit les séquences mais explose en taille, ne gère pas les néologismes, les fautes de frappe ni les langues agglutinantes, et laisse une masse de jetons rares mal estimés.

Le compromis dominant est le codage par paires d'octets (Byte-Pair Encoding, BPE), importé de la compression de données vers la traduction automatique par Sennrich, Haddow et Birch en 2016 [13]. L'algorithme d'apprentissage tient en quatre lignes :

1. Partir du vocabulaire des symboles élémentaires (caractères, ou les 256 octets).
2. Compter, sur le corpus, la fréquence de chaque paire de symboles adjacents.
3. Fusionner la paire la plus fréquente en un nouveau symbole ; l'enregistrer dans la liste ordonnée des fusions.
4. Répéter jusqu'à atteindre la taille de vocabulaire visée.

À l'usage, on réapplique les fusions dans l'ordre où elles ont été apprises : la tokenisation est déterministe. Les variantes courantes sont WordPiece (BERT ; critère de fusion fondé sur la vraisemblance et non la fréquence brute) et Unigram LM (SentencePiece [14] ; on part d'un gros vocabulaire et on élague les unités les moins utiles).

3.2 — Plongements : la table de correspondance

Chaque identifiant de jeton \(v \in \{1,\dots,|V|\}\) indexe une ligne d'une matrice apprise \(E \in \mathbb{R}^{|V|\times d}\). L'opération est un lookup, mathématiquement équivalent au produit d'un vecteur one-hot par \(E\), mais implémenté comme un accès mémoire. Pour \(|V|=128\,000\) et \(d=8\,192\), cette seule table pèse un milliard de paramètres.

Ces vecteurs ne sont pas conçus, ils sont appris. Leur géométrie encode de la structure distributionnelle : la similarité cosinus \(\cos(u,v) = \frac{u\cdot v}{\|u\|\|v\|}\) entre plongements corrèle avec la substituabilité contextuelle. Les célèbres analogies vectorielles de word2vec [15] (roi − homme + femme ≈ reine) montrent que certaines relations sémantiques sont approximativement linéaires dans cet espace — un fait empirique remarquable, dont la robustesse a d'ailleurs été surestimée : l'analogie ne tient que sur un sous-ensemble de relations et après exclusion des mots d'entrée.

Beaucoup de modèles lient la matrice d'entrée et la matrice de sortie (\(W_{\text{out}} = E^\top\), weight tying) : cela économise \(|V|\cdot d\) paramètres et améliore souvent la perte sur les modèles de taille modeste. Les modèles très grands tendent à les délier.

3.3 — Positions : l'attention est aveugle à l'ordre

Il faut le noter explicitement, car c'est contre-intuitif : le mécanisme d'attention est équivariant par permutation. Si l'on permute les jetons d'entrée, les sorties se permutent de la même façon — aucune information d'ordre n'est présente. Sans encodage positionnel, « le chien mord l'homme » et « l'homme mord le chien » produiraient les mêmes représentations, à permutation près.

Trois familles de solutions ont été employées :

• Sinusoïdale (article de 2017) — on ajoute au plongement un vecteur fixe de sinus et cosinus à fréquences géométriquement espacées. Aucun paramètre, extrapolation médiocre.
• Apprise absolue (GPT-2, BERT) — une table \(P\in\mathbb{R}^{S_{\max}\times d}\) apprise. Simple, mais rigoureusement inutilisable au-delà de \(S_{\max}\).
• RoPE (Rotary Position Embedding [16]) — le standard actuel. Plutôt que d'ajouter une information de position, on fait tourner les vecteurs de requête et de clé, par paires de coordonnées, d'un angle proportionnel à la position :

La propriété qui fait tout l'intérêt de RoPE est que le produit scalaire résultant ne dépend que de l'écart de position :

On obtient donc un encodage relatif au prix d'une opération absolue, compatible avec le cache clé-valeur (§7.2). L'extension de contexte se fait en manipulant la base \(b\) ou en interpolant les positions (méthodes dites de position interpolation et YaRN) : on ne réentraîne pas le modèle depuis zéro, on l'ajuste sur quelques milliards de jetons longs.

Une seule idée nouvelle en 2017 : remplacer la récurrence par une opération de routage entièrement parallélisable. Tout ce qui suit dans l'industrie en découle.

4.1 — Attention à produit scalaire mis à l'échelle

Chaque position produit trois vecteurs par projection linéaire du flux résiduel : une requête \(q\) (ce que je cherche), une clé \(k\) (ce que j'offre) et une valeur \(v\) (ce que je transmets si l'on me choisit). Sous forme matricielle, avec \(X\in\mathbb{R}^{n\times d}\) :

Décomposons, car chaque terme a une raison d'être :

• \(QK^\top\) produit une matrice \(n\times n\) de scores de compatibilité : combien la position \(i\) s'intéresse-t-elle à la position \(j\).
• Le softmax par ligne transforme ces scores en une distribution de probabilité : chaque position répartit une masse d'attention totale de 1 sur les positions accessibles. L'attention est un mécanisme de routage normalisé.
• La multiplication par \(V\) calcule une moyenne pondérée des valeurs. La sortie est donc toujours dans l'enveloppe convexe des vecteurs valeurs.

Pourquoi \(\sqrt{d_k}\) ? Supposons \(q\) et \(k\) à composantes indépendantes de moyenne nulle et de variance 1. Alors \(q\cdot k = \sum_{i=1}^{d_k} q_ik_i\) a une variance de \(d_k\), donc un écart-type \(\sqrt{d_k}\). Pour \(d_k=128\), les scores s'étalent typiquement sur ±11 ; le softmax d'un tel vecteur est quasi un one-hot, son gradient est quasi nul, et l'entraînement s'arrête. Diviser par \(\sqrt{d_k}\) ramène la variance à 1 et maintient le softmax dans son régime informatif. L'instrument IV mesure cet effet directement.

4.2 — Le masque causal

Pour un modèle génératif, la position \(i\) ne doit pas voir \(j > i\), sans quoi la tâche de prédiction du jeton suivant devient triviale. On ajoute donc, avant le softmax, une matrice \(M\) telle que \(M_{ij} = -\infty\) si \(j > i\) et 0 sinon. Après exponentiation, ces entrées valent exactement zéro.

L'élégance de ce dispositif est qu'il permet d'entraîner sur les \(n\) positions simultanément en une seule passe : les cibles sont l'entrée décalée d'un cran. C'est la raison technique du succès du Transformer face aux réseaux récurrents, qui devaient dérouler la séquence pas à pas. Le gain de parallélisme sur GPU est de l'ordre du facteur \(n\).

4.3 — Têtes multiples

Une seule attention ne calcule qu'une moyenne pondérée : c'est peu expressif. On exécute donc \(h\) mécanismes en parallèle sur des sous-espaces de dimension \(d_k = d/h\), et l'on concatène :

Le coût total est identique à celui d'une tête de dimension \(d\), puisque \(h \cdot d_k = d\). Ce que l'on gagne, c'est \(h\) motifs de routage indépendants par couche. L'analyse mécaniste (§9) montre que des têtes se spécialisent effectivement — têtes de position précédente, têtes de duplication, têtes d'induction — mais que cette spécialisation est partielle et qu'une même tête sert souvent plusieurs fonctions.

4.4 — Le bloc complet, et le flux résiduel

Un bloc de décodeur moderne s'écrit, en pré-norme :

Cette forme suggère une lecture qui s'est révélée féconde : le vecteur \(h\) est un flux résiduel, une sorte de mémoire de travail de dimension \(d\) que chaque bloc lit (via la normalisation) et dans laquelle il écrit par addition. L'attention déplace de l'information entre positions ; le bloc FFN transforme l'information à une position donnée et constitue, en nombre de paramètres, les deux tiers du modèle. Une interprétation soutenue par plusieurs travaux voit dans le FFN une mémoire associative clé-valeur : la première matrice détecte des motifs, la seconde écrit les vecteurs correspondants dans le flux.

Au sommet, une dernière normalisation puis la projection de dévectorisation vers \(\mathbb{R}^{|V|}\) produit les logits. Puis softmax, puis la perte (3). Le modèle entier tient en une trentaine de lignes de code ; la difficulté est ailleurs.

4.5 — Le coût quadratique, et FlashAttention

Pour une séquence de longueur \(n\), l'attention exige \(O(n^2 d)\) opérations et, dans une implémentation naïve, \(O(n^2)\) de mémoire pour matérialiser la matrice de scores. À \(n = 128\,000\) et 64 têtes, cette matrice pèserait des téraoctets. Le contexte long serait impraticable.

FlashAttention [22,23] résout le problème mémoire sans approximation. L'observation est que sur un GPU moderne, le goulot n'est pas le calcul mais les transferts entre la mémoire haut débit (HBM, quelques téraoctets par seconde) et la mémoire partagée du multiprocesseur (SRAM, deux ordres de grandeur plus rapide). L'algorithme découpe \(Q\), \(K\), \(V\) en tuiles, calcule l'attention tuile par tuile en SRAM, et agrège les résultats grâce à une formulation en ligne du softmax — on maintient au fil de l'eau le maximum courant \(m\) et la somme courante \(\ell\), en rééchelonnant l'accumulateur à chaque nouvelle tuile. La matrice \(n\times n\) n'est jamais écrite en HBM.

Résultat : mémoire en \(O(n)\), même nombre d'opérations arithmétiques (voire un peu plus, car on recalcule pendant la passe arrière), mais 2 à 4 fois moins de temps en pratique. Il faut retenir la leçon générale : en apprentissage profond à l'échelle, l'algorithme le plus rapide n'est pas celui qui fait le moins d'opérations, mais celui qui fait le moins de mouvements de données.

Les alternatives approchées — attention creuse, fenêtres glissantes, attention linéaire, modèles à espace d'états (Mamba) — réduisent l'exposant plutôt que la constante. Elles sont utilisées en production dans des architectures hybrides, mais aucune n'a à ce jour supplanté l'attention dense complète en qualité à budget égal.

4.6 — Mélange d'experts : découpler paramètres et calcul

Dans un Transformer dense, chaque jeton traverse tous les paramètres. Le mélange d'experts (MoE [24,25]) rompt ce couplage : le bloc FFN est remplacé par \(E\) experts et un routeur qui, pour chaque jeton, en sélectionne les \(k\) meilleurs (typiquement \(k=1\) ou 2).

Un modèle peut ainsi compter 400 milliards de paramètres totaux mais n'en activer que 30 milliards par jeton : le coût de calcul suit les paramètres actifs, la capacité de mémorisation suit les paramètres totaux. Les difficultés sont réelles — équilibrage de charge entre experts (on ajoute une perte auxiliaire), instabilité d'entraînement, et surtout empreinte mémoire à l'inférence, puisque tous les experts doivent être résidents même si l'on n'en utilise qu'une fraction. C'est un compromis en faveur du calcul, au détriment de la mémoire.

Passer d'un prototype à un modèle de production n'est pas un changement de degré mais de nature : les contraintes dominantes deviennent la bande passante mémoire, la topologie du réseau d'interconnexion et la qualité des données.

5.1 — Les données : le facteur le moins documenté

Un corpus de pré-entraînement moderne représente 10¹³ à 10¹⁴ jetons, agrégés depuis des extractions web (Common Crawl), du code, des livres, des articles scientifiques, des encyclopédies. Le traitement compte autant que la collecte :

• Extraction et nettoyage — passage du HTML au texte, suppression des gabarits, de la navigation, du contenu généré automatiquement.
• Filtrage qualité — heuristiques (longueur de ligne, taux de ponctuation, proportion de mots du lexique) puis classifieurs entraînés à distinguer le texte « de référence » du tout-venant.
• Déduplication — exacte et approchée (MinHash, filtres de Bloom), à l'échelle du document et du passage. C'est probablement l'intervention au meilleur rapport coût/bénéfice : la duplication dégrade la perte de validation, augmente la mémorisation verbatim et gaspille du budget.
• Décontamination — retrait des ensembles d'évaluation présents dans le corpus. Rarement complet, et systématiquement source de surestimation des performances (§10.3).
• Composition et curriculum — pondération des sources, éventuellement variable au fil de l'entraînement (données de haute qualité concentrées en fin de parcours).

Le détail de ces pipelines est le secret industriel le mieux gardé du domaine, davantage que l'architecture — laquelle est, à quelques variantes près, publique et convergente.

5.2 — Précision numérique

La supériorité de bf16 sur fp16 tient à un seul point : même nombre de bits d'exposant que fp32. La plage dynamique est donc préservée et les débordements de gradient disparaissent, au prix d'une mantisse plus courte. Or l'apprentissage profond tolère très bien le bruit de quantification — c'est un processus stochastique par nature — mais pas les infinis. La technique de fond reste l'entraînement en précision mixte [26] : calcul en basse précision, accumulation et mise à jour des poids en fp32.

5.3 — Paralléliser : quatre découpages orthogonaux

Aucun modèle sérieux ne tient sur un accélérateur. On combine simultanément :

À cela s'ajoute ZeRO [27], qui partitionne non pas le calcul mais l'état de l'optimiseur (moments, gradients, puis poids) entre les instances du parallélisme de données, supprimant la redondance des 16 octets par paramètre évoqués en §2.4. Megatron-LM [28] a formalisé le parallélisme de tenseurs. La combinaison de ces axes s'appelle le parallélisme 3D (ou 4D), et son réglage — quelle dimension sur quel niveau de la hiérarchie réseau — détermine l'utilisation effective des accélérateurs, typiquement 35 à 55 % du pic théorique sur les très grands entraînements.

5.4 — Le budget de calcul

De la comptabilité de §2.2 découle l'approximation universellement employée, due à Kaplan et al. [29] :

Elle néglige le coût de l'attention proprement dite, qui ajoute environ \(12\,L\,S\,d\) FLOP par jeton et devient non négligeable quand \(S \gtrsim d\) — au-delà de quelques dizaines de milliers de jetons de contexte, il faut en tenir compte. Un ordre de grandeur pour fixer les idées : \(N = 7\times10^{10}\), \(D = 1{,}5\times10^{13}\) donne \(C \approx 6{,}3\times10^{24}\) FLOP, soit environ 6 semaines sur 8 000 accélérateurs à 40 % d'utilisation.

5.5 — Lois d'échelle : le résultat empirique central

La perte décroît de façon remarquablement régulière — en loi de puissance — avec le nombre de paramètres, la quantité de données et le calcul, sur plus de sept ordres de grandeur [29]. La forme paramétrique ajustée par Hoffmann et al. (« Chinchilla », 2022 [30]) est :

avec, pour les valeurs publiées : \(E = 1{,}69\) nat/jeton, \(A = 406{,}4\), \(B = 410{,}7\), \(\alpha = 0{,}34\), \(\beta = 0{,}28\). Sous la contrainte \(6ND = C\), la minimisation par multiplicateur de Lagrange donne une solution en forme close :

Les exposants étant proches de ½, paramètres et données doivent croître à peu près à la même vitesse. C'est la correction majeure apportée à la doctrine antérieure (Kaplan 2020), qui privilégiait fortement la taille du modèle et avait conduit à une génération entière de modèles sous-entraînés : GPT-3, avec 175 milliards de paramètres pour 300 milliards de jetons (ratio 1,7), aurait obtenu une meilleure perte à budget identique avec quatre fois moins de paramètres et bien plus de données.

Un modèle pré-entraîné complète du texte. Il ne répond pas à des questions, ne suit pas d'instructions et n'a aucune raison de refuser quoi que ce soit. Le transformer en assistant est une seconde phase, mille fois moins coûteuse et tout aussi déterminante.

6.1 — Ajustement supervisé

Première étape : un ajustement fin sur des paires (instruction, réponse) écrites ou validées par des humains, avec la même perte d'entropie croisée (3) — appliquée toutefois aux seuls jetons de réponse. Quelques dizaines de milliers à quelques millions d'exemples suffisent. L'effet est spectaculaire par rapport au coût, ce qui a nourri l'« hypothèse de l'alignement superficiel » : le pré-entraînement installe les capacités, l'ajustement ne fait que sélectionner un format et un registre déjà présents dans la distribution. C'est une hypothèse plausible, partiellement étayée, mais pas démontrée.

6.2 — Modèle de récompense et apprentissage par renforcement

Pour beaucoup de propriétés recherchées — utilité, honnêteté, style, innocuité — on ne sait pas écrire une réponse de référence, mais on sait comparer deux réponses. On collecte donc des préférences \((x, y_w \succ y_l)\) et on ajuste un modèle de récompense \(r_\phi\) sous le modèle de Bradley-Terry :

Puis on optimise la politique \(\pi_\theta\) pour maximiser cette récompense, sous pénalité de divergence par rapport à la politique de référence [32,33] :

Le terme de KL n'est pas cosmétique : il est structurellement nécessaire. Le modèle de récompense n'est qu'un approximateur appris sur un échantillon fini ; sans contrainte, l'optimisation trouve des régions où \(r_\phi\) est élevé et faux. C'est le reward hacking, et il se manifeste de façon très reconnaissable : réponses interminables, listes à puces surabondantes, flatterie systématique, mise en garde rituelle. La complaisance excessive des assistants n'est pas un accident : c'est la conséquence prévisible d'optimiser un proxy de la satisfaction humaine.

6.3 — DPO : supprimer l'étape de renforcement

Rafailov et al. [34] observent que le problème (17) admet une solution optimale analytique, \(\pi^\star(y\mid x) \propto \pi_{\text{ref}}(y\mid x)\exp(r(x,y)/\beta)\), que l'on peut inverser pour exprimer la récompense en fonction des politiques. En substituant dans (16), le modèle de récompense disparaît et il ne reste qu'une perte de classification directement optimisable :

Plus de modèle de récompense séparé, plus d'échantillonnage en ligne, plus de PPO : un gain considérable en simplicité et en stabilité. Le prix est la perte de l'exploration en ligne — DPO n'apprend que sur les préférences déjà collectées. En pratique, les deux familles coexistent, souvent en variantes itératives où l'on régénère des préférences à chaque tour.

6.4 — Superviser avec un modèle

L'annotation humaine coûte cher et passe mal à l'échelle. L'IA constitutionnelle [35] remplace une partie du jugement humain par le modèle lui-même, guidé par un ensemble explicite de principes écrits : le modèle critique et révise ses propres réponses, puis les préférences sont générées par un modèle jugeant selon la constitution (RLAIF). L'avantage est double : passage à l'échelle, et surtout explicitation des critères, qui deviennent un document auditable plutôt qu'une distribution implicite dans les annotations. La limite est claire : on ne peut superviser ainsi que ce que le modèle superviseur sait déjà évaluer.

6.5 — Ce que l'alignement ne fait pas

• Il ne supprime pas les capacités indésirables ; il modifie la propension à les exercer. Elles restent accessibles — d'où l'existence des attaques par contournement.
• Il n'installe pas de vérité. Il récompense des réponses jugées correctes par des annotateurs, ce qui est un critère différent et faillible.
• Il ne garantit aucune généralisation hors distribution : le comportement sur des entrées très éloignées des données de préférence reste largement imprévisible.
• Il encode nécessairement des choix de valeurs — ceux des rédacteurs des consignes et des annotateurs. Il n'existe pas d'alignement neutre.

Servir un modèle est un problème d'ingénierie distinct de l'entraînement, dominé par la bande passante mémoire. C'est là que se joue le coût réel.

7.1 — Décoder : transformer une distribution en texte

À chaque pas, le modèle fournit un vecteur de logits \(z \in \mathbb{R}^{|V|}\). La stratégie de décodage choisit le jeton :

La raison profonde pour laquelle la recherche du maximum de vraisemblance produit du mauvais texte est instructive : le langage humain n'est pas la séquence la plus probable de sa propre distribution. Un texte naturel a une surprise à peu près constante et non minimale ; maximiser la probabilité conduit systématiquement vers des régions de très faible entropie, c'est-à-dire des répétitions [36]. Échantillonner n'est donc pas un pis-aller : c'est la manière correcte d'utiliser un modèle de densité.

7.2 — Le cache clé-valeur

Générer naïvement \(n\) jetons coûterait \(O(n^2)\) passes complètes, puisqu'il faudrait recalculer l'attention sur tout le préfixe à chaque pas. Or les clés et valeurs des positions déjà traitées ne changent pas — le masque causal le garantit. On les conserve donc en mémoire. Le décodage devient une passe par jeton, mais le cache grossit linéairement :

Ce cache devient rapidement le poste dominant. D'où deux familles de réponses. MQA [37] fait partager une unique paire clé-valeur par toutes les têtes ; GQA [38] adopte le compromis de \(g\) groupes (typiquement 8), ce qui divise le cache par \(h/g\) — souvent un facteur 8 à 16 — avec une dégradation de qualité marginale. Côté système, PagedAttention [39] gère le cache comme une mémoire virtuelle paginée : blocs de taille fixe, table de pages par séquence, partage de préfixe entre requêtes. La fragmentation tombe de plus de 60 % à quelques pour cent, et le débit d'un serveur double ou triple sans toucher au modèle.

7.3 — Préremplissage et décodage : deux régimes opposés

C'est le point le plus mal compris de l'inférence. Le préremplissage traite tout le prompt en parallèle : c'est un produit matrice-matrice, avec une intensité arithmétique élevée, donc limité par le calcul. Le décodage génère un jeton à la fois : à lot unitaire, c'est un produit matrice-vecteur, qui lit l'intégralité des poids du modèle pour effectuer 2 FLOP par paramètre — soit une intensité arithmétique d'environ 1 FLOP par octet en bf16.

Or un accélérateur haut de gamme actuel offre de l'ordre de 10³ TFLOP/s pour 3 To/s de bande passante, soit un équilibre machine autour de 300 FLOP par octet. Le décodage à lot unitaire s'exécute donc à moins de 1 % de la puissance de calcul disponible : il est intégralement limité par la mémoire. Trois conséquences pratiques, toutes vérifiables avec l'instrument ci-dessous :

• Le regroupement de requêtes (batching) est presque gratuit tant que l'on reste limité par la mémoire — c'est le principal levier de débit d'un serveur.
• La quantification des poids accélère directement le décodage, non par gain de calcul mais parce qu'il y a moins d'octets à lire.
• Réduire la taille du modèle et sur-entraîner (§5.5) est une stratégie économiquement rationnelle.

7.4 — Décodage spéculatif

Puisque le décodage est limité par la mémoire, le calcul est disponible gratuitement. On peut donc l'utiliser pour deviner. Un petit modèle « brouillon » propose \(\gamma\) jetons ; le grand modèle les vérifie tous en une seule passe (ce qui coûte à peu près le prix d'un seul jeton, puisqu'on lit les poids une fois) ; une règle d'acceptation-rejet garantit que la distribution finale est exactement celle du grand modèle [40]. Accélération typique : 2 à 3 fois, sans aucune perte de qualité. C'est l'un des rares repas gratuits du domaine.

7.5 — Quantification

Réduire la précision des poids après entraînement. La difficulté est que la distribution des activations des grands modèles comporte des valeurs aberrantes systématiques, concentrées sur quelques dimensions du flux résiduel, dont l'écrasement détruit la qualité [41]. Les méthodes efficaces les traitent séparément (précision mixte par canal), ou reconstruisent les poids couche par couche en minimisant l'erreur de sortie sur des données de calibration (GPTQ, AWQ). En pratique, 8 bits est transparent, 4 bits coûte quelques dixièmes de point sur les évaluations, en dessous la dégradation devient nette. QLoRA [42] combine base quantifiée en 4 bits et adaptateurs de rang faible [43] entraînés en bf16, permettant d'ajuster un modèle de 70 milliards de paramètres sur un seul accélérateur.

Certaines aptitudes n'ont jamais été enseignées explicitement. Comprendre d'où elles viennent — et jusqu'où le constat est solide — est l'un des chantiers les plus actifs et les plus disputés du domaine.

8.1 — Apprentissage en contexte

Le fait le plus surprenant établi par GPT-3 [44] : donner quelques exemples dans le prompt améliore les performances, sans qu'aucun poids ne soit modifié. Le modèle infère la tâche à partir de la démonstration. Ce n'est pas de l'apprentissage au sens du gradient — rien n'est mémorisé d'une requête à l'autre — mais un comportement conditionnel émergent du pré-entraînement.

L'explication mécaniste la mieux étayée passe par les têtes d'induction [45]. C'est un circuit à deux têtes réparties sur deux couches : la première, dite « tête de position précédente », copie dans le flux résiduel de chaque position l'identité du jeton qui la précède ; la seconde s'en sert pour rechercher une occurrence antérieure du jeton courant et recopier ce qui l'avait suivi. Le circuit implémente donc littéralement le motif [A][B] … [A] → [B].

Deux éléments rendent cette explication convaincante. D'abord, la formation de ces têtes coïncide avec une bosse visible sur la courbe de perte, une transition de phase nette et reproductible en début d'entraînement. Ensuite, l'apparition de l'apprentissage en contexte, mesurée indépendamment, coïncide avec cette même transition. La corrélation est forte et documentée sur des dizaines de modèles ; l'inférence causale complète, pour des tâches non triviales, reste ouverte.

8.2 — Chaîne de pensée et calcul au moment de l'inférence

Il faut voir la contrainte architecturale : un Transformer effectue une quantité de calcul fixe par jeton produit, soit \(L\) couches, ni plus ni moins. Une question exigeant vingt étapes de raisonnement ne peut donc pas être résolue « d'un coup » si \(L\) est insuffisant. Sauf à utiliser une astuce : écrire les étapes intermédiaires, qui deviennent des jetons du contexte et donc des entrées pour les passes suivantes.

C'est la chaîne de pensée [46]. Le contexte sert de mémoire externe ; générer plus de jetons revient à s'accorder plus de profondeur de calcul effective. Formellement, on transforme une contrainte de profondeur en une contrainte de longueur — et la longueur est bien plus facile à étendre.

Les modèles dits « de raisonnement » industrialisent cette idée : on entraîne le modèle par renforcement à produire de longues chaînes internes, avec pour signal la justesse de la réponse finale (vérifiable en mathématiques, en code, sur des tâches à réponse unique). Une nouvelle loi d'échelle apparaît alors, non plus sur le calcul d'entraînement mais sur le calcul au moment du test : la performance progresse avec le budget de jetons de réflexion accordé.

8.3 — Le débat sur l'émergence

Wei et al. [47] ont documenté des capacités qualifiées d'émergentes : nulles au niveau du hasard jusqu'à une certaine échelle, puis brusquement présentes. Si le phénomène était réel et général, il rendrait la sécurité par extrapolation impossible : on ne pourrait pas prévoir ce qu'un modèle plus grand saura faire.

Schaeffer et al. [48] ont opposé une critique forte : la discontinuité serait en grande partie un artefact de la métrique. Les mesures de type « correspondance exacte » ou « réponse juste sur cinq choix » sont non linéaires et à seuil ; une amélioration lisse et régulière de la probabilité par jeton se traduit mécaniquement par un saut de la métrique agrégée. Avec des mesures continues — distance d'édition, score de Brier, log-vraisemblance de la bonne réponse — les mêmes courbes deviennent lisses et prévisibles.

L'état des lieux honnête, en 2026 : la critique métrique explique une large part des cas rapportés, mais pas nécessairement tous, et le débat n'est pas clos. La conséquence pratique fait, elle, consensus : on ne dispose d'aucune méthode fiable pour prédire les capacités en aval d'un modèle non encore entraîné, alors même que l'on prédit sa perte de pré-entraînement avec une précision remarquable. C'est précisément l'écart entre ces deux capacités de prédiction qui rend le déploiement difficile à sécuriser.

On connaît chaque poids et chaque opération. On ne comprend pas pour autant ce que le réseau calcule. L'interprétabilité mécaniste tente de reconstruire les algorithmes appris, à partir des activations.

9.1 — La superposition

Une hypothèse naturelle veut que chaque neurone corresponde à un concept. Elle est fausse : les neurones sont massivement polysémantiques, s'activant sur des ensembles d'entrées sans rapport apparent. L'explication proposée par Elhage et al. [49] est la superposition.

L'argument repose sur un fait de géométrie : dans \(\mathbb{R}^d\), on ne peut placer que \(d\) vecteurs strictement orthogonaux, mais on peut en placer un nombre exponentiel en \(d\) qui soient presque orthogonaux (lemme de Johnson–Lindenstrauss). Si les traits à représenter sont parcimonieux — peu d'entre eux actifs simultanément sur une entrée donnée — le réseau peut leur attribuer des directions quasi orthogonales et tolérer l'interférence, qui reste rare. Il représente ainsi bien plus de traits qu'il n'a de dimensions. La polysémanticité n'est pas un défaut d'organisation : c'est le symptôme d'un schéma de compression.

9.2 — Autoencodeurs parcimonieux

Si les traits sont superposés dans une base non alignée sur les neurones, il faut retrouver la bonne base. C'est un problème de dictionary learning, abordé par des autoencodeurs parcimonieux : on entraîne \(h \approx \sum_i a_i(h)\,f_i\) avec un dictionnaire \(\{f_i\}\) surcomplet (bien plus de traits que de dimensions) et une pénalité de parcimonie sur les coefficients \(a_i\).

Les résultats sont substantiels [50,51]. Sur un modèle de production, la méthode extrait des dizaines de millions de traits nettement plus monosémantiques que les neurones : entités précises, constructions syntaxiques, concepts abstraits, motifs de code, et — plus notable pour la sécurité — des traits correspondant à des notions comme la tromperie, la flagornerie, ou l'insécurité d'un code. Ces traits sont causalement actifs : les amplifier ou les supprimer modifie le comportement de façon prévisible.

9.3 — Ce que cela ne résout pas

• La couverture reste partielle : la reconstruction laisse une erreur résiduelle non négligeable, et l'on ignore quelle fraction du calcul est capturée.
• Trouver des traits n'est pas comprendre des circuits. Le passage des traits aux algorithmes qui les composent reste largement manuel et n'a été mené à terme que sur des tâches étroites.
• Le nombre de traits croît avec la taille du dictionnaire sans plateau clair : rien ne garantit qu'il existe un ensemble fini et « correct » de traits à découvrir.
• Le coût est élevé : entraîner les autoencodeurs d'un grand modèle est un projet de recherche à part entière.

L'honnêteté impose de dire où l'on en est : l'interprétabilité mécaniste a fait des progrès réels et rapides, et elle n'offre pas aujourd'hui de garanties de sûreté. Elle produit des hypothèses testables et des leviers de contrôle partiels, non une vérification.

Les défauts les plus tenaces ne sont pas des bogues à corriger : ce sont des conséquences directes de l'objectif d'entraînement décrit en §1.2.

10.1 — Pourquoi l'hallucination est structurelle

Reprenons (3). Le modèle maximise la vraisemblance d'un corpus. Rien dans cet objectif ne distingue vrai de plausible : une affirmation fausse mais bien formée et statistiquement typique reçoit une probabilité élevée. Le modèle n'a par ailleurs aucun mécanisme interne d'accès à une base de faits ; il n'a que des paramètres qui encodent des régularités.

Trois mécanismes concourent, et il faut les distinguer car ils appellent des remèdes différents [54] :

• Interpolation. Sollicité sur un fait absent ou rare dans le corpus, le modèle produit néanmoins la continuation la plus vraisemblable — une référence bibliographique de la bonne forme, un numéro d'article plausible. La forme est apprise, le contenu est inventé.
• Structure d'incitation. Si l'évaluation récompense l'exactitude et pénalise également le silence et l'erreur, alors deviner domine toujours l'abstention. Les protocoles d'évaluation dominants ont ainsi optimisé l'assurance mal placée.
• Cascade auto-régressive. Une erreur produite entre dans le contexte et conditionne la suite ; le modèle reste cohérent avec sa propre erreur.

Les atténuations connues — génération augmentée par recherche, vérification par outils externes, entraînement explicite à l'abstention, mesure de cohérence entre échantillons multiples — réduisent le taux mais ne suppriment pas le phénomène, parce qu'aucune ne change l'objectif sous-jacent.

10.2 — Calibration

Un modèle est calibré si, parmi les affirmations auxquelles il assigne 80 % de confiance, environ 80 % sont exactes. Les modèles de base sont souvent remarquablement bien calibrés sur des questions à choix multiples. Fait établi et instructif : l'ajustement par préférences dégrade la calibration [53]. On l'explique aisément — l'optimisation d'un signal de préférence humaine pousse le modèle vers un registre assuré, l'assurance étant préférée par les annotateurs. On échange donc une propriété épistémique contre une propriété rhétorique.

10.3 — Évaluer, et pourquoi c'est difficile

10.4 — Ce que personne ne sait

Une section qu'aucun exposé sérieux ne devrait omettre. En l'état des connaissances publiées :

• Il n'existe aucune théorie prédictive de la généralisation pour les réseaux surparamétrés à l'échelle réelle. Les lois d'échelle sont des régularités empiriques, non des théorèmes ; on ignore pourquoi elles sont des lois de puissance, et si elles se prolongeront.
• On ne sait pas prédire les capacités en aval à partir de la perte, alors qu'on prédit la perte très bien.
• On ne sait pas localiser un fait dans les paramètres de façon fiable, ni l'éditer sans effets de bord.
• On ne sait pas vérifier l'absence d'un comportement. Les évaluations échantillonnent un espace d'entrées astronomique ; l'absence de preuve n'est pas une preuve d'absence.
• La question de savoir si ces systèmes construisent des modèles du monde ou exploitent des corrélations statistiques de surface reste débattue. Les deux camps disposent d'arguments empiriques sérieux, et la question est probablement mal posée sous cette forme binaire : il existe un continuum de représentations plus ou moins structurées, et l'on manque d'instruments pour situer un modèle donné sur ce continuum.
• Les propriétés internes restent, pour l'essentiel, opaques : l'interprétabilité couvre une fraction du calcul, et personne ne peut affirmer connaître la totalité des algorithmes implémentés par un modèle de production.

Ces lacunes ne diminuent pas la valeur de ce qui précède. Elles délimitent ce que l'on peut affirmer. Un exposé technique qui les tairait serait, précisément, moins rigoureux.

Références primaires, dans l'ordre de leur première citation. Les identifiants arXiv sont donnés lorsqu'ils existent ; il est prudent de les vérifier avant citation formelle.