Qu'est-ce qu'un modèle de langage ?¶

Intuition : une machine à compléter¶

Intuition

Un grand modèle de langage (LLM, Large Language Model) est une fonction mathématique géante qui reçoit un début de texte et répond à une seule question : quel est le morceau de texte le plus probable juste après ?

Rien de plus. Ni base de données, ni moteur de recherche, ni raisonnement symbolique programmé à la main. Une fonction qui prend une suite de symboles et produit une distribution de probabilité sur le symbole suivant.

Toute la richesse apparente — écrire du code, résoudre un problème de physique, piloter un navigateur — vient de deux faits :

cette fonction a été ajustée sur une quantité de texte gigantesque, ce qui l'a forcée à encoder des régularités du monde pour bien prédire ;
on l'applique en boucle : le jeton produit est ajouté au texte d'entrée, et on recommence.

La formulation mathématique¶

Notons \(x_1, x_2, \ldots, x_T\) une suite de symboles (nous verrons au chapitre 02 que ce ne sont pas des lettres ni des mots, mais des jetons). Un modèle de langage définit une probabilité pour la suite entière, décomposée par la règle des probabilités conditionnelles :

\[ P(x_1, \ldots, x_T) = \prod_{t=1}^{T} P(x_t \mid x_{<t}) \]

Symbole	Signification
\(x_t\)	Le jeton à la position \(t\)
\(x_{<t}\)	Tous les jetons qui précèdent la position \(t\)
\(P(x_t \mid x_{<t})\)	Probabilité du jeton \(t\) sachant tout ce qui précède
\(T\)	Longueur de la suite

Le modèle, c'est l'objet qui calcule \(P(x_t \mid x_{<t})\). On note ses paramètres \(\theta\) (des milliards de nombres réels) et on écrit \(P_\theta(x_t \mid x_{<t})\).

Erreur fréquente

« Le modèle choisit le mot le plus probable. » Faux en général : le modèle produit une distribution sur tout le vocabulaire, et une procédure d'échantillonnage séparée en tire un jeton. Avec une température de 1,0 (le réglage recommandé pour Kimi K3), on tire au hasard selon cette distribution. Deux exécutions identiques peuvent donc donner des réponses différentes.

Un exemple numérique minuscule¶

Supposons un vocabulaire de 5 jetons : ["le", "chat", "chien", "dort", "."]. Le modèle reçoit le chat et produit un vecteur de 5 nombres, appelés logits :

\[ \mathbf{z} = (-1{,}2,\; 0{,}3,\; -0{,}5,\; 3{,}1,\; 0{,}8) \]

On les transforme en probabilités par la fonction softmax :

\[ P(x_t = j) = \frac{e^{z_j}}{\sum_{i=1}^{V} e^{z_i}} \]

où \(V\) est la taille du vocabulaire. Numériquement : \(e^{-1{,}2}=0{,}30\), \(e^{0{,}3}=1{,}35\), \(e^{-0{,}5}=0{,}61\), \(e^{3{,}1}=22{,}2\), \(e^{0{,}8}=2{,}23\). Leur somme vaut \(26{,}7\). Donc :

Jeton	Logit	Probabilité
`le`	\(-1{,}2\)	1,1 %
`chat`	\(0{,}3\)	5,1 %
`chien`	\(-0{,}5\)	2,3 %
`dort`	\(3{,}1\)	83,1 %
`.`	\(0{,}8\)	8,4 %

Le modèle « pense » à 83 % que la suite est dort. Kimi K3 fait exactement cela, mais avec un vocabulaire de 163 840 jetons et 2 800 milliards de paramètres pour produire ces logits.

À retenir

Le vocabulaire de Kimi K3 compte 163 840 entrées. La dernière opération du modèle est donc une multiplication qui projette un vecteur de dimension 7 168 vers 163 840 logits, suivie d'un softmax.

La génération : une boucle¶

texte = "Explique-moi la gravité"
répéter :
    logits   = modèle(texte)          # un vecteur de 163 840 nombres
    proba    = softmax(logits)
    jeton    = tirer_au_hasard(proba) # échantillonnage
    texte    = texte + jeton
jusqu'à ce que jeton == [fin de message]

Deux conséquences majeures, qui structurent tout le rapport Kimi K3 :

La génération est séquentielle. On ne peut pas produire le jeton 100 avant le jeton 99. C'est ce qui rend l'inférence lente et motive le décodage spéculatif.
Le coût croît avec la longueur du texte déjà produit. Chaque nouveau jeton doit « regarder » tout ce qui précède. À 1 million de jetons de contexte, ce coût devient le problème central. C'est la raison d'être de KDA.

Les deux régimes de calcul : prefill et decode¶

Quand vous envoyez une requête, le modèle traite d'abord tout votre texte d'entrée d'un coup : c'est le prefill (pré-remplissage). Il peut le faire en parallèle sur tous les jetons, car ils sont déjà connus. C'est une phase limitée par le calcul (compute-bound).

Ensuite il produit la réponse un jeton à la fois : c'est le decode. À chaque étape, un seul jeton est traité, mais il faut relire tous les paramètres du modèle depuis la mémoire. C'est une phase limitée par la bande passante mémoire (memory-bound).

Intuition

Prefill = lire un livre en diagonale, toutes les pages ouvertes en même temps. Decode = écrire une lettre, mot par mot, en relisant tout le livre avant chaque mot.

Ces deux régimes ont des goulots d'étranglement différents, ce qui explique pourquoi le rapport Kimi K3 décrit des noyaux de calcul distincts pour l'un et pour l'autre (voir Noyaux d'inférence).

Ce qu'un LLM n'est pas¶

Limite importante

Ce n'est pas une base de faits. Ce qu'il « sait » est encodé de façon diffuse dans ses poids, sans mécanisme de vérification. D'où les hallucinations : le modèle produit un enchaînement plausible, pas vrai. Le rapport Kimi K3 mesure explicitement ce phénomène avec un banc Faithfulness (85,5 % pour K3, voir benchmarks internes).
Ce n'est pas un programme déterministe. À température 1,0, deux appels identiques divergent.
Ce n'est pas un agent en soi. Un modèle seul ne peut ni lire un fichier ni exécuter du code. Il faut un harnais qui exécute les outils qu'il demande (voir chapitre 13).

Vérification de compréhension¶

Pourquoi dit-on que la génération est « auto-régressive » ?

Parce que la sortie du modèle à l'étape \(t\) devient une partie de son entrée à l'étape \(t+1\). Le modèle se nourrit de sa propre production — d'où auto (soi-même) et régressif (revenir sur les valeurs passées).

Un modèle de 2,8 T de paramètres qui n'en active que 104 G est-il « plus petit » ?

Non. Il faut stocker les 2,8 T (soit environ 1,56 To sur disque en MXFP4), mais on n'en calcule que 104 G par jeton. La mémoire reste le coût dominant ; c'est le calcul qui est réduit. Voir Mixture-of-Experts.

Chapitre suivant : Jetons et tokenisation