Comment un LLM predit le prochain mot

Tout ce qu’un LLM fait — répondre à tes questions, écrire du code C#, résumer un document, traduire entre langues — repose sur un seul mécanisme, surprenamment simple à énoncer : prédire le token suivant le plus probable. Comprendre ce mécanisme en profondeur, c’est comprendre pourquoi les LLMs sont si puissants, pourquoi ils hallucinent, et comment écrire des prompts qui exploitent leurs forces tout en contournant leurs faiblesses.

Qu’est-ce qu’un token exactement ?

Un token n’est pas exactement un mot. C’est l’unité de base que le modèle traite — un morceau de texte qui peut être un mot entier, une partie de mot, un signe de ponctuation, ou même un espace.

Le processus qui découpe le texte en tokens s’appelle la tokenisation. GPT-4 utilise un tokenizer appelé BPE (Byte Pair Encoding) qui construit son vocabulaire en fusionnant progressivement les paires de bytes les plus fréquentes dans le corpus d’entraînement.

Quelques exemples concrets :

Texte	Tokens (approximatif)	Nombre de tokens
“chat”	[“chat”]	1
“développement”	[“dével”, “oppe”, “ment”]	3
“ASP.NET Core”	[“AS”, “P”, “.”, “NET”, ” Core”]	5
“Bonjour, comment vas-tu ?”	[“Bon”, “jour”, “,”, ” comment”, ” vas”, “-“, “tu”, ” ?”]	8
Code C# simple (10 lignes)	~80-120 tokens	~100

En moyenne : 1 token ≈ 0,75 mot en anglais, et légèrement moins en français car le français a des mots plus longs et des constructions plus complexes qui se tokenisent moins efficacement (les tokenizers sont généralement optimisés pour l’anglais).

Implication pratique : Si tu envoies un prompt en français à GPT-4o, tu utilises en moyenne 15-20% plus de tokens qu’en anglais pour la même information. Sur des volumes importants, ça peut avoir un impact non négligeable sur les coûts. Pour des applications à haute fréquence, considère d’écrire le system prompt en anglais même si le contenu utilisateur est en français.

La prédiction token par token — le cœur du mécanisme

Quand tu envoies “Quelle est la capitale de la France ?” à un LLM, voici ce qui se passe réellement, étape par étape :

Tokenisation : ton texte est découpé en tokens [“Quelle”, ” est”, ” la”, ” capitale”, ” de”, ” la”, ” France”, ” ?”]
Embedding : chaque token est converti en un vecteur de haute dimension (ex: 12 288 dimensions pour GPT-4). Ces vecteurs encodent la sémantique du token.
Attention multi-têtes : le modèle calcule les relations entre tous les tokens en parallèle. “capitale” va fortement “attirer” “France” et “ville”.
Propagation dans les couches : les représentations passent par des dizaines à des centaines de couches Transformer, chacune raffinant la compréhension du contexte.
Projection sur le vocabulaire : la sortie finale est convertie en un vecteur de probabilités sur les ~50 000 tokens du vocabulaire.
Sampling : un token est sélectionné selon ces probabilités (pas toujours le plus probable — dépend de la temperature).
Récursion : le token sélectionné est ajouté à l’entrée, et tout recommence depuis l’étape 1.

Résultat : “Paris” apparaît token par token, puis “.” puis le token de fin de séquence. Le modèle n’a jamais “pensé” à la réponse complète — il a généré chaque token séquentiellement, en recalculant entièrement l’attention à chaque étape.

Le paramètre Temperature — comprendre le sampling

Après l’étape 5, le modèle a une distribution de probabilités sur 50 000 tokens. La temperature contrôle comment on échantillonne dans cette distribution :

Temperature = 0 : on prend toujours le token le plus probable. Réponses déterministes, répétitives, “sûres”.
Temperature = 0.7 : on tire aléatoirement selon les probabilités. Bonne balance créativité/cohérence.
Temperature = 1.0 : on suit exactement les probabilités brutes du modèle.
Temperature > 1.0 : on “aplatit” la distribution, rendant les tokens improbables plus probables. Réponses plus créatives mais souvent incohérentes.

// Exemples de configuration temperature selon le cas d'usage

// Génération de code — déterministe, on veut le résultat le plus probable
var codeOptions = new ChatCompletionOptions
{
    Temperature = 0.1f,  // Quasi-déterministe
    MaxOutputTokenCount = 2000
};

// Assistant conversationnel — balance naturalité/cohérence
var chatOptions = new ChatCompletionOptions
{
    Temperature = 0.7f,  // Défaut recommandé pour les chats
    MaxOutputTokenCount = 1000
};

// Génération créative (histoires, brainstorming, slogans)
var creativeOptions = new ChatCompletionOptions
{
    Temperature = 1.0f,  // Plus de variété
    MaxOutputTokenCount = 500
};

// Extraction de données structurées — on veut exactement ce qu'on demande
var extractionOptions = new ChatCompletionOptions
{
    Temperature = 0.0f,  // Complètement déterministe
    MaxOutputTokenCount = 500
};

// Test : même prompt, temperatures différentes
var client = new ChatClient("gpt-4o", Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);

var testPrompt = new List<ChatMessage>
{
    ChatMessage.CreateUserMessage("Complète cette phrase : 'Le développeur ouvrit son IDE et...")
};

for (float temp = 0f; temp <= 1.5f; temp += 0.5f)
{
    var options = new ChatCompletionOptions { Temperature = temp };
    var response = await client.CompleteChatAsync(testPrompt, options);
    Console.WriteLine($"Temperature {temp}: {response.Value.Content[0].Text}");
}

Le mécanisme d’attention — pourquoi les LLMs “comprennent” le contexte

La révolution du Transformer par rapport aux architectures précédentes (RNN, LSTM) est le mécanisme d’attention. Il permet au modèle de regarder simultanément tous les tokens du contexte et de décider lesquels sont pertinents pour prédire le prochain token.

Intuition mathématique

Pour chaque token, le modèle calcule trois vecteurs :

Query (Q) : “De quelle information j’ai besoin ?”
Key (K) : “Quelle information je peux fournir ?”
Value (V) : “Quelle est mon contenu réel ?”

Le score d’attention entre deux tokens = Q₁ · K₂ (produit scalaire). Plus deux vecteurs sont similaires, plus le score est élevé, plus le token 2 influence la représentation du token 1.

Dans “La banque de données a planté, l’équipe a perdu toutes les transactions stockées sur la rive”, le mot “banque” a un sens ambigu. Le mécanisme d’attention va calculer que “données”, “transactions”, “stockées” ont des scores élevés avec “banque” — et pas “rive”. Résultat : “banque” est correctement interprété comme institution financière/informatique, pas comme rive d’une rivière.

Multi-head attention — plusieurs perspectives simultanées

GPT-4 utilise des centaines de “têtes” d’attention en parallèle. Chaque tête apprend à se spécialiser dans un type de relation différent :

Une tête se spécialise dans les relations sujet-verbe
Une autre dans les relations pronoms-antécédents
Une autre dans les patterns syntaxiques
Une autre dans les dépendances sémantiques à longue distance

Le résultat de toutes ces têtes est concatené et projeté pour former la représentation finale du token — riche de toutes ces perspectives simultanées. C’est ce qui permet aux LLMs de maintenir la cohérence sur des textes très longs.

Pourquoi les LLMs hallucinent — et comment en tenir compte

Maintenant que tu comprends le mécanisme, les hallucinations deviennent logiques et prévisibles :

Un LLM ne cherche pas la vérité — il cherche le token suivant statistiquement le plus plausible étant donné le contexte. Si tu lui demandes “Quelle est la date exacte de naissance de Jean Dupont, développeur PHP chez Société X ?”, le modèle va générer une date qui “ressemble” à une réponse correcte — parce que statistiquement, une question sur une date de naissance est suivie d’une date.

Il n’a pas de mécanisme pour dire “je ne sais pas” de façon fiable. Il peut l’apprendre via le fine-tuning (RLHF), mais c’est imparfait. La prédiction du token suivant le plus probable peut tout à fait générer une information fausse avec la même confiance qu’une vraie.

Les 4 types d’hallucinations et comment les détecter

Type	Exemple	Comment détecter	Mitigation
Factuelle	Date historique inventée	Vérification externe	RAG, grounding sur sources vérifiables
Citation	Citation attribuée à quelqu’un qui ne l’a pas dite	Recherche de la citation originale	Demander “as-tu une source ?” dans le prompt
Code	Méthode d’API qui n’existe pas, version de library incorrecte	Compilation, tests	Toujours compiler et tester avant de commiter
Raisonnement	Erreur logique dans un calcul complexe	Chain-of-thought, vérification manuelle	Temperature=0, chain-of-thought prompting

Stratégies anti-hallucination en .NET

// Stratégie 1 : Grounding — donner les faits dans le prompt
// Le modèle ne peut "inventer" que ce qui n'est pas dans le contexte

var systemPrompt = """
    Tu es un assistant qui répond aux questions sur nos produits.
    Tu ne dois répondre QUE depuis les informations suivantes.
    Si la réponse n'est pas dans ces informations, dis "Je n'ai pas cette information".
    
    CATALOGUE PRODUITS :
    - Widget Pro : 299€, garantie 2 ans, disponible en rouge et bleu
    - Widget Lite : 149€, garantie 1 an, disponible en noir uniquement
    - Widget Max : 499€, garantie 3 ans, toutes couleurs disponibles
    """;

// Stratégie 2 : Demander une réponse JSON structurée avec indicateur de confiance
var extractionPrompt = """
    Analyse ce contrat et extrait les informations suivantes en JSON.
    Pour chaque champ, indique un niveau de confiance (high/medium/low).
    Si tu n'es pas sûr, mets "unknown" plutôt qu'inventer.
    
    Format attendu :
    {
        "parties": [{"name": "...", "role": "...", "confidence": "high"}],
        "date_signature": {"value": "...", "confidence": "high"},
        "montant": {"value": ..., "currency": "...", "confidence": "medium"},
        "duree_mois": {"value": ..., "confidence": "low"}
    }
    """;

// Stratégie 3 : Self-consistency — appeler plusieurs fois et comparer
async Task<string> GetConsistentAnswer(ChatClient client, string question, int attempts = 3)
{
    var answers = new List<string>();
    
    for (int i = 0; i < attempts; i++)
    {
        var messages = new List<ChatMessage>
        {
            ChatMessage.CreateSystemMessage("Réponds de façon concise et précise."),
            ChatMessage.CreateUserMessage(question)
        };
        
        var options = new ChatCompletionOptions { Temperature = 0.3f };
        var response = await client.CompleteChatAsync(messages, options);
        answers.Add(response.Value.Content[0].Text);
    }
    
    // Si toutes les réponses sont similaires → haute confiance
    // Si elles divergent → signaler l'incertitude
    var allSimilar = answers.Distinct().Count() == 1;
    
    if (!allSimilar)
    {
        return $"Réponses divergentes détectées. Vérification manuelle recommandée. " +
               $"Réponses obtenues : {string.Join(" | ", answers)}";
    }
    
    return answers[0];
}

La fenêtre de contexte — la mémoire de travail du LLM

Le mécanisme d’attention calcule les relations entre tous les tokens — mais seulement ceux qui sont dans la fenêtre de contexte. Au-delà, le modèle ne “voit” plus rien.

Pense à la fenêtre de contexte comme la mémoire de travail du modèle : tout ce qui peut influencer la réponse actuelle doit tenir dans cette fenêtre. Ce qui en est sorti est inaccessible — comme si ça n’avait jamais existé.

Fenêtres actuelles (2026) :

GPT-4o : 128 000 tokens (~350 pages de texte)
Claude 3.5 Sonnet : 200 000 tokens (~550 pages)
Gemini 1.5 Pro : 1 000 000 tokens (~2750 pages)
GPT-4o mini : 128 000 tokens (même fenêtre que GPT-4o, moins cher)

Piège courant : Une grande fenêtre de contexte ne veut pas dire une mémoire infinie. Les modèles ont tendance à “perdre” les informations qui se trouvent au milieu d’un très long contexte — ils sont plus précis sur le début et la fin. Ce phénomène s’appelle le “lost in the middle problem”. Si tu envoies un document de 100 pages, les informations des pages 40-70 risquent d’être moins bien prises en compte. Mets toujours les informations critiques au début ou à la fin du contexte.

RLHF — pourquoi le modèle “se comporte bien”

Un modèle entraîné uniquement à prédire le prochain token depuis internet produirait des contenus parfois toxiques, biaisés, ou incohérents — parce qu’internet contient tout ça.

C’est là qu’intervient le RLHF (Reinforcement Learning from Human Feedback) — la technique utilisée par OpenAI, Anthropic, et Google pour aligner les LLMs sur les valeurs humaines :

Supervised Fine-Tuning (SFT) : des humains écrivent des réponses idéales à des milliers de prompts variés. Le modèle apprend à imiter ces réponses.
Reward Model : des annotateurs humains comparent des paires de réponses et choisissent la meilleure. Un modèle de récompense apprend à prédire ces préférences humaines.
PPO (Proximal Policy Optimization) : le LLM est optimisé pour maximiser les scores du reward model — c’est du renforcement classique où la récompense est la préférence humaine simulée.

Résultat : le modèle apprend à être utile, inoffensif, et honnête — pas parce qu’il “comprend” ces valeurs, mais parce que les réponses qui les incarnent ont été récompensées pendant l’entraînement.

Ce que tout ça change pour tes prompts

Comprendre le mécanisme de prédiction token par token a des implications directes sur la façon d’écrire des prompts efficaces :

Le début du prompt compte énormément : les premiers tokens conditionnent toutes les prédictions suivantes. Un system prompt mal formulé “teinte” toute la conversation.
L’ordre des informations compte : mets les instructions avant les données, pas l’inverse. “Résume ce texte en 3 points : [texte]” fonctionne mieux que “[texte] Résume ça en 3 points”.
La température doit correspondre à la tâche : extraction de données → 0.0, conversation → 0.7, créativité → 1.0.
Plus de contexte = meilleure prédiction : donne des exemples (few-shot), précise le format attendu, décris ton contexte métier.
Les hallucinations sont prévisibles : plus la question est précise sur un domaine spécifique, plus le risque d’hallucination est élevé. Préfère des questions vérifiables ou fournis les faits dans le prompt.

Exercice pratique

Voici un exercice en 3 parties pour ancrer ces concepts :

Partie 1 — Observer la tokenisation : Va sur platform.openai.com/tokenizer et tokenise ces textes. Compte les tokens et compare :

Le même paragraphe en français et en anglais
Un extrait de code C# de 10 lignes
Un extrait de code JSON avec les mêmes données

Partie 2 — Observer l’effet de la temperature : Avec le code de cette leçon, envoie le même prompt 5 fois avec temperature=0 et 5 fois avec temperature=1. Observe la variabilité des réponses dans chaque cas.

Partie 3 — Provoquer et éviter une hallucination : Demande au modèle un fait très précis et obscur (date de naissance d’une personne peu connue, numéro d’une version de library très spécifique). Observe l’hallucination. Puis refais la même question en ajoutant “Si tu n’es pas sûr à 100%, dis-le explicitement et ne génère pas de réponse inventée.” Compare les résultats.

Récapitulatif

Un LLM génère du texte token par token, en recalculant l’attention à chaque étape
Un token ≈ 0,75 mot en anglais, légèrement moins en français
La temperature contrôle la créativité : 0 = déterministe, 0.7 = équilibré, 1+ = créatif
L’attention permet au modèle de relier des tokens distants — c’est ce qui crée la “compréhension” du contexte
Les hallucinations viennent du mécanisme probabiliste : le token le plus plausible, pas le plus vrai
Le RLHF aligne le comportement du modèle sur les préférences humaines
Connaitre le mécanisme te rend meilleur pour écrire des prompts et anticiper les erreurs

Prochaine leçon : la fenêtre de contexte en détail — comment la gérer dans tes applications .NET, les stratégies de mémoire, et les patterns d’architecture pour les apps de chat en production.

Qu’est-ce qu’un token exactement ?

La prédiction token par token — le cœur du mécanisme

Le paramètre Temperature — comprendre le sampling

Le mécanisme d’attention — pourquoi les LLMs “comprennent” le contexte

Intuition mathématique

Multi-head attention — plusieurs perspectives simultanées

Pourquoi les LLMs hallucinent — et comment en tenir compte

Les 4 types d’hallucinations et comment les détecter

Stratégies anti-hallucination en .NET

La fenêtre de contexte — la mémoire de travail du LLM

RLHF — pourquoi le modèle “se comporte bien”

Ce que tout ça change pour tes prompts

Exercice pratique

Récapitulatif

🎁 Ebook C# 14 gratuit — offert maintenant