Inférence

Le moment où le modèle tourne pour de vrai : la boucle qui écrit le texte, un token à la fois, par opposition à l'entraînement où il apprend.

7 min de lecture

#génération
#échantillonnage
#déploiement
#performance

En une phrase

L’inférence, c’est le moment où l’on se sert du modèle au lieu de l’entraîner : ses poids ne bougent plus, et il écrit sa réponse un token à la fois, en relisant à chaque tour tout ce qui précède.

L’analogie

Un musicien passe des années au conservatoire : c’est l’entraînement. Puis il monte sur scène : c’est l’inférence. Il n’apprend plus rien, il joue avec ce qu’il sait.

Et s’il improvise, il ne rejoue pas un solo écrit en coulisses : il pose une note, l’écoute avec les précédentes, choisit la suivante. Un LLM écrit comme ça, sans connaître sa dernière phrase quand il attaque la première.

Comment ça marche

La boucle, un token à la fois

Le modèle ne sait faire qu’une chose : recevoir un texte et parier sur le token suivant. L’inférence boucle là-dessus — le token retenu est recollé au texte, qui repart en entrée pour un nouveau pari. C’est la génération autorégressive : chaque sortie devient une partie de l’entrée suivante.

Trois choses l’arrêtent : un token de fin (EOS, end of sequence), le plafond fixé par l’appelant, une séquence d’arrêt demandée. Aucun plan nulle part : la phrase entière n’existe pas avant d’avoir été écrite.

Prefill et decode : deux régimes, deux coûts

Au prefill, le modèle lit ta question en entier : tous ses tokens traversent le réseau en une seule passe. Au decode, chaque token exige sa propre passe, et rien n’est parallélisable — le douzième ne se calcule pas avant le onzième. Pire, chaque passe relit tous les poids depuis la mémoire de la carte pour n’en produire qu’un. Un modèle de 70 milliards de paramètres en 16 bits, c’est 140 Go à déplacer par mot : sur une H100 SXM qui pousse 3,35 To/s, le plancher est d’environ 42 ms par token, pendant que les unités de calcul s’ennuient.

Le prefill bute donc sur le calcul, le decode sur la bande passante mémoire, d’où deux mesures : le temps jusqu’au premier token (TTFT), qui s’allonge avec le prompt, et les tokens par seconde. La facture suit — un token de sortie coûte le plus souvent quatre à cinq fois un token d’entrée. Le cache clés-valeurs, lui, est traité dans la fiche Fenêtre de contexte.

Du logit au token : l’échantillonnage

En fin de passe, le modèle sort un nombre brut par entrée du vocabulaire : un logit — pas encore une probabilité, ça peut être négatif et ça ne totalise rien. Trois étapes précèdent le tirage.

La température divise tous les logits : en dessous de 1 le favori écrase les autres, au-dessus les outsiders remontent.
Le softmax les convertit en probabilités qui font 100 % ensemble : la liste que montre l’animation ci-dessous.
La coupe écarte la longue traîne d’absurdités à 0,001 % qui finirait par sortir. Le top-k garde les k meilleurs candidats ; le top-p, ou échantillonnage par noyau, le plus petit groupe dont les probabilités cumulées atteignent p — deux candidats quand le modèle est sûr, des centaines quand il hésite.

Deux précautions, parce que c’est là que les vulgarisations dérapent. La température ne choisit rien, elle déforme la distribution ; l’échantillonnage est le tirage. Et leur ordre change d’un moteur à l’autre : Hugging Face applique la température en premier, llama.cpp en dernier.

Pourquoi la température zéro ne garantit rien

À zéro, la division serait impossible : les logiciels retiennent alors sans tirage le candidat le mieux noté. C’est le décodage glouton (greedy decoding), déterministe sur le papier.

En pratique, non. Ta requête est calculée en même temps que d’autres, et le découpage du travail entre les cœurs dépend du nombre de requêtes présentes. Or l’addition de nombres à virgule flottante n’est pas associative : dans un autre ordre le résultat change très légèrement, et deux candidats presque à égalité s’inversent. Horace He et le Thinking Machines Lab l’ont montré en 2025 : la cause n’est pas le hasard du GPU, mais des calculs qui ne sont pas invariants à la taille du lot.

Une passe de decode ne demande qu’à être remplie

Puisque le decode attend la mémoire, les poids chargés pour un token peuvent en produire cent, pour cent utilisateurs, dans la même passe. C’est le batching : tu paies ta part d’un passage collectif, et c’est pourquoi un token d’API coûte si peu. Encore faut-il que le lot ne bloque pas derrière sa requête la plus longue — le batching continu (Orca, Yu et al., 2022) rebat les cartes à chaque token, et vLLM (Kwon et al., 2023) y ajoute une gestion du cache empruntée aux systèmes d’exploitation : deux à quatre fois plus de débit à latence égale. Revers : ta latence dépend de la charge des autres, et ce lot mouvant cause le non-déterminisme vu plus haut.

Même logique pour le décodage spéculatif : un petit modèle rédige un brouillon, le gros le vérifie d’un coup et corrige le premier écart. La règle d’acceptation garantit exactement la distribution du gros modèle seul, deux à trois fois plus vite (Leviathan et al., 2023).

Visualisation

Au premier tour, « ␣can » sort à 45 % devant « ␣lit » à 22 % : un carrefour qu’une température plus haute aurait fait basculer. Au suivant, « apé » est à 97 % — plus de choix, le modèle finit son mot. Dix paris pour finir la phrase.

Comment le modèle écrit-il, mot après mot ?

Le chat dort sur le▌

Étape 1/6 On donne un début de phrase au modèle. Sa seule mission : trouver le morceau suivant. Pas la phrase entière — juste le morceau suivant.

Chiffres illustratifs, choisis pour rendre le mécanisme lisible.

Dans la vraie vie

Le texte qui s’affiche mot à mot dans ChatGPT, Claude ou Vibe n’est pas un effet de style : il est fabriqué ainsi. Le streaming n’accélère rien, il découpe l’attente.
OpenAI et Anthropic vendent tous deux un mode « par lots » à moitié prix, réponse sous 24 heures : tu renonces à l’immédiateté pour être rangé dans le lot qui arrange le fournisseur.
Une complétion de code doit arriver avant que tu aies fini la ligne : sur ce chemin-là, on met des modèles bien plus petits.
Sur un Mac, un modèle local tourne d’abord grâce à la bande passante de la mémoire unifiée — 546 Go/s sur une M4 Max, 819 sur une M3 Ultra — plus que grâce aux cœurs graphiques. Une quantification réduit d’autant les octets à déplacer.

Idées reçues

« Le modèle apprend pendant notre conversation. » Non : à l’inférence, les poids sont en lecture seule, les mêmes pour tous au même instant. Ce que tu écris pèse sur la réponse parce que c’est relu à chaque tour, pas parce que c’est inscrit.
« À température zéro, la même question donne toujours la même réponse. » Sur ta machine, oui. Sur un serveur partagé, non : le résultat dépend du nombre de requêtes traitées en même temps que la tienne. Un seed fige le tirage au sort, pas l’arithmétique.
« Le modèle rédige sa réponse, puis te l’affiche mot à mot. » C’est l’inverse : il l’affiche mot à mot parce qu’il la fabrique mot à mot. Y compris quand il « réfléchit » : les tokens de raisonnement sortent de la même boucle, et sont facturés pareil.

Pour aller plus loin

« The Curious Case of Neural Text Degeneration » — Holtzman et al., ICLR 2020 (EN) : viser toujours le plus probable produit un texte plat, d’où le top-p.
« How to generate text » — Patrick von Platen, 2020 (EN) : glouton, faisceau, température, top-k et top-p, code à l’appui.
« Defeating Nondeterminism in LLM Inference » — Horace He, Thinking Machines Lab, 2025 (EN) : l’enquête sur la température zéro qui ne se reproduit pas.
« Fast Inference from Transformers via Speculative Decoding » — Leviathan, Kalman et Matias, 2023 (EN) : le décodage spéculatif et sa preuve d’équivalence.
« Efficient Memory Management for LLM Serving with PagedAttention » — Kwon et al., 2023 (EN) : le papier de vLLM.
Comprendre l’inférence d’un LLM — Stéphane Robert, 2026 (FR) : prefill, decode et métriques de latence, sans mathématiques.