Jour 24 Day 24 · jeudi 3 septembre 2026 Thursday 3 September 2026 IA Fondamental

Comment marche un LLM How an LLM works

Prédire le token suivant, encore et encore : c'est tout ce que fait un LLM. Comprendre pourquoi ça suffit — et où ça casse — est devenu une question d'entretien incontournable, même pour un stage de dev classique. Predicting the next token, over and over: that's all an LLM does. Understanding why that's enough — and where it breaks — has become an unavoidable interview question, even for a regular dev internship.

L’essentiel

Un LLM (Large Language Model) ne fait qu’une seule chose : prédire le token suivant. On lui donne un début de texte, il calcule une probabilité pour chaque token de son vocabulaire (~100 000 entrées), on en choisit un, on l’ajoute au texte, et on recommence. C’est la génération autorégressive : ChatGPT, Claude ou Llama ne « répondent » pas, ils complètent token par token un document qui a la forme d’une conversation.

La vraie question est : pourquoi ça suffit ? Parce que pour bien prédire la suite d’un texte, le modèle est obligé de capturer tout ce qui rend cette suite prévisible : la grammaire, les faits fréquents, le style, et jusqu’à la structure des raisonnements. Un « raisonnement » de LLM n’est pas un moteur logique caché derrière le texte — c’est la continuation statistiquement plausible d’un texte qui ressemble à un raisonnement. C’est ce qui le rend puissant, et c’est exactement ce qui le fait se tromper avec assurance.

Comment ça marche

Le pipeline complet, du prompt à la réponse :

        "Le chat" (texte)
             │  tokenizer (BPE)
             ▼
        [1169, 9852]   ← tokens = des entiers
             │  embedding
             ▼
        vecteurs (1 par token)
             │
    ┌────────▼─────────┐
    │   Transformer    │  N blocs : chaque token
    │  attention + MLP │  "regarde" les précédents,
    └────────┬─────────┘  pondérés par pertinence
             ▼
   probabilités sur tout le vocabulaire
   "dort" 31%   "mange" 12%   "est" 9% …
             │  sampling (température, top-p)
             ▼
        token choisi : "dort"
             │
             └──▶ ajouté au texte, et on boucle

Tokenization — le texte est découpé en tokens : des fragments fréquents (mot entier, morceau de mot, ponctuation) appris par un algorithme type BPE (Byte Pair Encoding). Ordre de grandeur : 1 token ≈ 3-4 caractères, ≈ 0,75 mot en anglais. Le modèle ne voit jamais de lettres, seulement des identifiants entiers.
Embeddings — en une phrase : chaque token est converti en un vecteur de nombres tel que la proximité géométrique reflète la proximité de sens (« roi » et « reine » sont voisins dans cet espace).
Attention, le cœur du transformer — à chaque couche, chaque token « regarde » tous les tokens qui le précèdent et pondère leur influence selon leur pertinence pour lui. Dans « Le chien de Marie dort parce qu’il est fatigué », le token il accorde un poids fort à chien et faible à Marie. Pas besoin des maths en entretien : retenir « contexte pondéré, calculé dynamiquement, en parallèle sur toute la séquence ». Ce parallélisme est ce qui a détrôné les RNN (papier Attention Is All You Need, 2017).
Sortie et boucle — après N blocs (attention + petit réseau feed-forward), le modèle produit la distribution du token suivant. Le sampling en tire un, et tout recommence avec un token de plus.

💡 Le piège « strawberry » — demandez à un LLM combien de « r » dans strawberry : beaucoup répondent 2. Normal : le mot arrive découpé en tokens (straw + berry), deux entiers sans notion de lettres. Compter des caractères, épeler à l’envers, poser une addition chiffre par chiffre : tout ce qui vit « sous » le niveau du token est structurellement difficile pour le modèle.

Concepts clés à maîtriser

Pré-entraînement — prédire le token suivant sur des milliers de milliards de tokens (web, livres, code). Résultat : un base model qui complète du texte mais ne « répond » pas — donnez-lui une question, il peut générer trois autres questions similaires.
Fine-tuning (SFT) — on ré-entraîne le base model sur des exemples de dialogues instruction → bonne réponse. Le modèle apprend le format assistant.
RLHF (Reinforcement Learning from Human Feedback) — des humains classent des paires de réponses ; on entraîne un modèle de récompense, puis on optimise le LLM contre lui. C’est ce qui rend le modèle utile, poli, et qui lui apprend à refuser certaines demandes.
Température et sampling — la température aplati ou accentue la distribution avant le tirage ; le top-p coupe la longue traîne :

Réglage	Effet	Cas d’usage
`temperature: 0`	quasi déterministe : toujours le token le plus probable	extraction, classification, code
`temperature: 0.7`	équilibre variété / cohérence	assistant, rédaction
`temperature: 1.5`	très aléatoire, dérive vite vers l’incohérent	brainstorming encadré
`top_p: 0.9`	ne tire que parmi le noyau couvrant 90 % de probabilité	couper les tokens absurdes

Fenêtre de contexte — la « mémoire de travail » : tout (system prompt, historique, documents) doit tenir dedans, et tout est re-traité à chaque appel. Limites concrètes : coût proportionnel à la taille, latence, et le phénomène lost in the middle (les informations au milieu d’un très long contexte sont moins bien exploitées que le début et la fin).
API stateless — le modèle ne « se souvient » de rien entre deux appels : c’est votre code qui renvoie tout l’historique à chaque requête.

from openai import OpenAI          # même logique chez Anthropic, Mistral…
client = OpenAI()

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        # "system" : cadre le comportement, prioritaire, invisible
        {"role": "system", "content": "Tu réponds en 2 phrases max."},
        # l'historique COMPLET est renvoyé à chaque appel :
        # l'API est stateless, rien n'est mémorisé côté modèle
        {"role": "user", "content": "C'est quoi un token ?"},
    ],
    temperature=0.2,   # bas = factuel et quasi reproductible
    max_tokens=150,    # plafond de génération (coût + latence)
)
print(resp.choices[0].message.content)

🎤 En entretien — « Explique un LLM à un non-technicien » : « C’est un autocomplete surpuissant. Comme le clavier du téléphone qui propose le mot suivant, mais entraîné sur une bibliothèque géante et capable de tenir compte de pages entières de contexte. Il ne sait pas ce qui est vrai — il sait ce qui est plausible. » Trois phrases, exactes, sans jargon : c’est ça qu’on évalue.

En entretien

« C’est quoi un LLM, en une phrase ? » — Un réseau de neurones (architecture transformer) entraîné à prédire le token suivant sur d’immenses corpus, puis affiné (fine-tuning + RLHF) pour suivre des instructions. Tout le reste — dialogue, code, raisonnement apparent — émerge de cet objectif.

« Pourquoi un LLM rate le nombre de “r” dans strawberry ? » — À cause de la tokenization : il manipule des identifiants de tokens, pas des lettres. strawberry arrive en deux ou trois fragments ; compter des caractères demande une information qu’il n’a jamais vue directement. Bonus : citer le même problème pour l’arithmétique posée et les anagrammes.

« Pré-entraînement, fine-tuning, RLHF : quelle différence ? » — Pré-entraînement : apprendre la langue et le monde en prédisant le token suivant (99 % du coût). Fine-tuning : apprendre le format instruction → réponse sur des exemples choisis. RLHF : aligner sur les préférences humaines via un modèle de récompense. Image utile : culture générale → formation au métier → savoir-être.

« À quoi sert la température ? » — Elle règle le caractère aléatoire du tirage : 0 = toujours le token le plus probable (extraction, tests reproductibles), plus haut = plus de diversité. Piège à désamorcer soi-même : température 0 ne rend pas le modèle plus juste, juste plus déterministe.

« Pourquoi les hallucinations ? » — Parce que l’objectif d’entraînement récompense la plausibilité, pas la vérité : le modèle n’a ni base de faits ni mécanisme natif pour dire « je ne sais pas ». Une référence inventée est souvent la continuation la plus probable d’une question pointue. Atténuations : RAG (fournir les sources dans le contexte), outils externes, demander des citations — mais pas de correctif définitif.

Pièges & idées reçues

⚠️ « Température 0 = mode vérité » — non : déterministe ≠ exact. Le token le plus probable peut être une hallucination très confiante. La reproductibilité n’est pas un gage de justesse, c’est juste moins de variance.

« Il comprend ce qu’il dit » — formulation piégeuse en entretien : préférez « il modélise des régularités statistiques du langage » et laissez la philosophie de côté.
« Il va chercher dans une base de données / sur Internet » — non : les connaissances sont figées dans les poids à l’entraînement (d’où le knowledge cutoff). Le browsing ou le RAG sont des outils externes branchés autour du modèle.
« Plus de contexte = toujours mieux » — un contexte énorme coûte cher, ralentit, et le modèle exploite mal le milieu (lost in the middle). Mieux vaut un contexte court et pertinent.
Confondre paramètres et contexte — les paramètres (7B, 70B…) sont les poids appris, figés ; la fenêtre de contexte est l’entrée temporaire d’un appel. Rien de ce qui passe dans le contexte ne « ré-entraîne » le modèle.

Pour aller plus loin

The Illustrated Transformer — Jay Alammar, la référence visuelle
But what is a GPT? — 3Blue1Brown, l’intuition en animation
Intro to Large Language Models — Andrej Karpathy, 1 h qui couvre tout ce sujet
Le tokenizer d’OpenAI — coller du texte et voir les tokens
Attention Is All You Need — le papier fondateur de 2017 (survoler les figures suffit)

The essentials

An LLM (Large Language Model) does exactly one thing: predict the next token. Give it the beginning of a text, it computes a probability for every token in its vocabulary (~100,000 entries), one token is picked, appended to the text, and the process repeats. That’s autoregressive generation: ChatGPT, Claude or Llama don’t “answer” — they complete, token by token, a document shaped like a conversation.

The real question is: why is that enough? Because to predict the continuation of a text well, the model is forced to capture everything that makes that continuation predictable: grammar, common facts, style, and even the structure of reasoning itself. An LLM’s “reasoning” is not a hidden logic engine behind the text — it’s the statistically plausible continuation of a text that looks like reasoning. That’s what makes it powerful, and it’s exactly what makes it confidently wrong.

How it works

The full pipeline, from prompt to answer:

        "The cat" (text)
             │  tokenizer (BPE)
             ▼
        [791, 8415]    ← tokens = integers
             │  embedding
             ▼
        vectors (1 per token)
             │
    ┌────────▼─────────┐
    │   Transformer    │  N blocks: each token
    │  attention + MLP │  "looks at" the previous
    └────────┬─────────┘  ones, weighted by relevance
             ▼
   probabilities over the whole vocabulary
   "sleeps" 31%   "eats" 12%   "is" 9% …
             │  sampling (temperature, top-p)
             ▼
        chosen token: "sleeps"
             │
             └──▶ appended to the text, and loop

Tokenization — text is split into tokens: frequent fragments (whole word, word piece, punctuation) learned by a BPE-style algorithm (Byte Pair Encoding). Order of magnitude: 1 token ≈ 3-4 characters, ≈ 0.75 English words. The model never sees letters, only integer identifiers.
Embeddings — in one sentence: each token is converted into a vector of numbers such that geometric closeness reflects closeness in meaning (“king” and “queen” are neighbors in that space).
Attention, the heart of the transformer — at each layer, every token “looks at” all the tokens before it and weights their influence by how relevant they are to it. In “Marie’s dog sleeps because it is tired”, the token it gives a strong weight to dog and a weak one to Marie. No math needed in an interview: remember “weighted context, computed dynamically, in parallel across the whole sequence”. That parallelism is what dethroned RNNs (the 2017 paper Attention Is All You Need).
Output and loop — after N blocks (attention + a small feed-forward network), the model produces the next-token distribution. Sampling picks one, and everything starts over with one more token.

💡 The “strawberry” trap — ask an LLM how many “r”s are in strawberry: many answer 2. Makes sense: the word arrives cut into tokens (straw + berry), two integers with no notion of letters. Counting characters, spelling backwards, doing digit-by-digit addition: everything living “below” the token level is structurally hard for the model.

Key concepts to master

Pre-training — predicting the next token on trillions of tokens (web, books, code). The result is a base model that completes text but doesn’t “answer” — give it a question and it may generate three more similar questions.
Fine-tuning (SFT) — the base model is retrained on examples of instruction → good answer dialogues. The model learns the assistant format.
RLHF (Reinforcement Learning from Human Feedback) — humans rank pairs of answers; a reward model is trained on those preferences, then the LLM is optimized against it. This is what makes the model helpful, polite, and teaches it to refuse some requests.
Temperature and sampling — temperature flattens or sharpens the distribution before drawing; top-p cuts the long tail:

Setting	Effect	Use case
`temperature: 0`	near deterministic: always the most probable token	extraction, classification, code
`temperature: 0.7`	balance of variety / coherence	assistant, writing
`temperature: 1.5`	very random, quickly drifts into incoherence	supervised brainstorming
`top_p: 0.9`	only samples from the nucleus covering 90% probability	cutting absurd tokens

Context window — the “working memory”: everything (system prompt, history, documents) must fit in it, and everything is reprocessed on every call. Concrete limits: cost proportional to size, latency, and the lost in the middle phenomenon (information in the middle of a very long context is used less well than the beginning and end).
Stateless API — the model “remembers” nothing between two calls: your code resends the entire history with every request.

from openai import OpenAI          # same logic at Anthropic, Mistral…
client = OpenAI()

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        # "system": frames the behavior, high priority, invisible
        {"role": "system", "content": "Answer in 2 sentences max."},
        # the FULL history is resent on every call:
        # the API is stateless, nothing is stored model-side
        {"role": "user", "content": "What is a token?"},
    ],
    temperature=0.2,   # low = factual and near reproducible
    max_tokens=150,    # generation cap (cost + latency)
)
print(resp.choices[0].message.content)

🎤 In an interview — “Explain an LLM to a non-technical person”: “It’s a supercharged autocomplete. Like your phone keyboard suggesting the next word, but trained on a giant library and able to take whole pages of context into account. It doesn’t know what’s true — it knows what’s plausible.” Three sentences, accurate, no jargon: that’s what’s being evaluated.

In an interview

“What’s an LLM, in one sentence?” — A neural network (transformer architecture) trained to predict the next token on huge corpora, then refined (fine-tuning + RLHF) to follow instructions. Everything else — dialogue, code, apparent reasoning — emerges from that objective.

“Why does an LLM miss the number of ‘r’s in strawberry?” — Because of tokenization: it manipulates token identifiers, not letters. strawberry arrives as two or three fragments; counting characters requires information it never directly saw. Bonus: mention the same problem for long-hand arithmetic and anagrams.

“Pre-training, fine-tuning, RLHF: what’s the difference?” — Pre-training: learning language and the world by predicting the next token (99% of the cost). Fine-tuning: learning the instruction → answer format on curated examples. RLHF: aligning with human preferences via a reward model. Useful image: general education → job training → soft skills.

“What is temperature for?” — It controls the randomness of sampling: 0 = always the most probable token (extraction, reproducible tests), higher = more diversity. Defuse the trap yourself: temperature 0 doesn’t make the model more correct, just more deterministic.

“Why hallucinations?” — Because the training objective rewards plausibility, not truth: the model has no fact database and no native mechanism to say “I don’t know”. An invented reference is often the most probable continuation of a niche question. Mitigations: RAG (put the sources in the context), external tools, asking for citations — but no definitive fix.

Pitfalls & misconceptions

⚠️ “Temperature 0 = truth mode” — no: deterministic ≠ correct. The most probable token can be a very confident hallucination. Reproducibility is no guarantee of accuracy, it’s just less variance.

“It understands what it says” — a loaded phrasing in interviews: prefer “it models statistical regularities of language” and leave the philosophy aside.
“It looks things up in a database / on the Internet” — no: knowledge is frozen into the weights at training time (hence the knowledge cutoff). Browsing or RAG are external tools plugged in around the model.
“More context = always better” — a huge context is expensive, slow, and the model exploits the middle poorly (lost in the middle). A short, relevant context beats a long noisy one.
Confusing parameters and context — parameters (7B, 70B…) are the learned weights, frozen; the context window is the temporary input of one call. Nothing that goes through the context “retrains” the model.

Going further

The Illustrated Transformer — Jay Alammar, the visual reference
But what is a GPT? — 3Blue1Brown, the intuition, animated
Intro to Large Language Models — Andrej Karpathy, 1 hour covering this whole topic
OpenAI’s tokenizer — paste text and see the tokens
Attention Is All You Need — the founding 2017 paper (skimming the figures is enough)

S'entraîner sur ce sujet → Practice this topic →