Un modèle génératif ne « sait » pas : il prédit ce qui est plausible. Comprendre cette différence est la clé pour s'en servir sans se faire piéger.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : avancé · 🏅 Badge : Explorateur des modèles
🎬 L'histoire
Un matin, Kodi demande à un assistant d'IA : « Combien de semaines dure le cours de réseaux de HashBox, et qui l'enseigne ? » La réponse arrive instantanément, fluide, sûre d'elle : « huit semaines, enseigné par Mme Lambert ». C'est bien huit semaines. Mais le nom est inventé : aucune Mme Lambert n'enseigne chez HashBox. Kodi n'a rien vu : la phrase était parfaitement écrite.
« Il n'a pas menti, dit Sam, il a fait exactement ce pour quoi il est construit : produire la suite la plus plausible. Et "Mme Lambert" est un nom plausible. Pour t'en servir en ingénierie, tu dois comprendre comment ça marche et où ça casse. Rien de magique : des probabilités, un contexte limité, et aucune source de vérité interne. »
Dans ce dernier module, tu apprends à utiliser l'IA comme un multiplicateur de capacité — sans lui déléguer ton jugement. Cette première mission te fait construire un minuscule modèle de langage pour voir, de tes yeux, comment naît une hallucination.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer le fonctionnement d'un modèle de langage : jetons, probabilités, prédiction du suivant
- construire et échantillonner un petit modèle à n-grammes (température, top-k, top-p)
- mesurer l'effet de la taille du contexte sur la fidélité et sur la créativité
- expliquer ce qu'est une hallucination et pourquoi elle est fluide et plausible
- énoncer les limites pratiques : contexte fini, non-déterminisme, connaissances datées, sensibilité à la formulation
🧩 Défi d'échauffement (5 XP)
Complète : « Le chat boit du ______ ». Plusieurs mots viennent. Lequel est le plus probable ? Le moins ? Maintenant complète : « La capitale de la Mongolie est ______ ». Quelle est la différence entre ces deux situations : dans l'une tu devines, dans l'autre tu sais (ou tu ne sais pas). Que se passe-t-il si tu devines avec aplomb quand tu ne sais pas ?
💡 Le concept
Ce qu'est un modèle de langage
Un modèle de langage estime la probabilité du mot suivant (plus exactement du jeton suivant) étant donné ce qui précède :
P(jeton suivant | contexte)
Pour produire un texte : on tire un jeton selon cette distribution, on l'ajoute au contexte, on recommence. C'est tout. Les grands modèles actuels utilisent des réseaux de neurones (architecture transformer) entraînés sur des quantités énormes de texte, mais le principe reste celui-là.
Les jetons
Le texte est découpé en jetons (tokens) : fragments de mots, mots courts, signes. Exemple : « réinitialisation » peut devenir ré, initial, isation. Conséquences pratiques :
- on paie et on est limité en jetons, pas en mots (en français, ≈ 1,3 à 1,6 jeton par mot) ;
- les mots rares, noms propres, nombres sont découpés en beaucoup de morceaux ;
- les fautes de frappe et le code ont leurs particularités.
Un algorithme classique de découpage : BPE (byte pair encoding) : on fusionne itérativement les paires de symboles les plus fréquentes.
De la distribution au texte : l'échantillonnage
| Réglage | Effet |
|---|---|
| Glouton (toujours le plus probable) | déterministe, répétitif |
Température T | p_i ∝ exp(logit_i / T) : T bas → plus déterministe ; T haut → plus varié et plus risqué |
| Top-k | on ne tire que parmi les k jetons les plus probables |
| Top-p (noyau) | on garde le plus petit ensemble de jetons dont la probabilité cumulée atteint p |
Même avec les mêmes entrées, un modèle échantillonné n'est pas déterministe : c'est une caractéristique, pas un bug. Pour des tâches qui exigent de la reproductibilité, on réduit la température et on fixe la graine quand l'outil le permet, mais cela ne garantit pas que la réponse soit exacte.
Ce que le modèle « sait »
Il a comprimé des régularités statistiques de ses données d'entraînement dans ses paramètres. Il n'a :
- pas de base de faits interrogeable avec garantie d'exactitude ;
- pas de notion interne de « je ne sais pas » fiable (il produit quand même quelque chose de plausible) ;
- aucun accès à ce qui est postérieur à son entraînement, ni à vos données privées, sauf si on les lui fournit dans le contexte ;
- aucune vérification de ses propres sorties (sauf si on lui fait appeler des outils et qu'on vérifie ensuite).
Les hallucinations
Une hallucination est une sortie plausible mais fausse ou non fondée : fait inventé, source inexistante, fonction d'une bibliothèque qui n'existe pas, citation fabriquée. Elle est dangereuse parce qu'elle est fluide et assurée — la forme ne trahit pas le fond.
Pourquoi ? Le modèle optimise la plausibilité, pas la véracité. Quand le contexte ne contient pas l'information (ou ne la lui rappelle pas), il comble avec ce qui ressemble à une réponse.
Facteurs aggravants : question sur un sujet rare, demande de détails précis (noms, nombres, références), contexte ambigu, pression à répondre, température élevée, long texte généré.
Les limites à connaître
| Limite | Conséquence |
|---|---|
| Fenêtre de contexte finie | au-delà, on oublie ou on tronque (mission 3) |
| Coupure des connaissances | les faits récents sont inconnus |
| Sensibilité à la formulation | deux questions équivalentes, deux réponses différentes (mission 2) |
| Biais | reflets des données d'entraînement |
| Raisonnement fragile | arithmétique, logique longue, comptage : erreurs possibles |
| Confidentialité | ce qu'on envoie peut être journalisé ou exposé selon le service (mission 9) |
| Coût et latence | proportionnels au nombre de jetons |
Le bon modèle mental
Un assistant d'IA est un stagiaire brillant, rapide, très cultivé, qui ne dit jamais « je ne sais pas » et qui peut inventer avec aplomb. Tu es responsable de ce que tu signes.
Il est excellent pour : brouillons, reformulations, exploration d'options, génération de code à vérifier, explication de concepts connus, transformations de format. Il est dangereux pour : faits précis non vérifiés, calculs sans outil, décisions à enjeu sans relecture.
Capacités et vérification
Plus la tâche est vérifiable à bas coût (un test qui passe, une compilation, un calcul qu'on peut refaire), plus l'IA est un excellent multiplicateur. Plus elle est difficile à vérifier (analyse juridique, contenu technique pointu), plus il faut un expert humain. C'est le fil rouge de tout le module (missions 7 et 8).
🧠 Astuce : quand une réponse d'IA est étonnamment précise sur un détail que tu ne connais pas (un nom, une date, une référence), c'est exactement le moment de la vérifier.
🔍 Exemple pas à pas
Problème : construire un petit modèle de langage à n-grammes entraîné sur des phrases vraies à propos des cours de HashBox, l'échantillonner (température, top-k, top-p), mesurer la part de phrases fausses mais plausibles en fonction de la taille du contexte, et illustrer le découpage en jetons par BPE.
import math, random, re
from collections import Counter, defaultdict
# ---------------- 1. corpus d'entraînement : uniquement des FAITS VRAIS ----------------
DUREES = {"algorithmes": "dix", "structures": "huit", "réseaux": "huit", "systèmes": "douze", "sécurité": "six", "tests": "cinq"}
PROFS = {"algorithmes": "Ada", "structures": "Bob", "réseaux": "Cléo", "systèmes": "Dan", "sécurité": "Eve", "tests": "Flo"}
CORPUS = [f"le cours de {c} dure {DUREES[c]} semaines" for c in DUREES] + [f"le cours de {c} est enseigné par {PROFS[c]}" for c in DUREES]
def est_vrai(phrase):
m = re.fullmatch(r"le cours de (\w+) dure (\w+) semaines", phrase)
if m: return DUREES.get(m.group(1)) == m.group(2)
m = re.fullmatch(r"le cours de (\w+) est enseigné par (\w+)", phrase)
if m: PROFS.get(m.group()) == m.group()
:
(): .ordre, .compteurs = ordre, defaultdict(Counter)
():
p phrases:
mots = [] * (.ordre - ) + p.split() + []
i (.ordre - , (mots)):
.compteurs[(mots[i - .ordre + :i])][mots[i]] +=
():
c = .compteurs[(contexte[-(.ordre - ):]) .ordre > ()]
poids = {m: n ** ( / temperature) m, n c.items()}
total = (poids.values()); dist = (((m, w / total) m, w poids.items()), key= x: -x[])
top_k: dist = dist[:top_k]
top_p:
cumul, garde = , []
m, p dist:
garde.append((m, p)); cumul += p
cumul >= top_p:
dist = garde
total = (p _, p dist); [(m, p / total) m, p dist]
():
mots = [] * (.ordre - )
(mots) < :
dist = .distribution(mots, **options)
mot = rng.choices([m m, _ dist], [p _, p dist])[]
mot == :
mots.append(mot)
.join(m m mots m != )
():
m = ModeleNgrammes(ordre); m.entrainer(CORPUS)
rng = random.Random(graine); phrases = [m.generer(rng, **options) _ (n)]
bien_formees = [p p phrases est_vrai(p) ]
vraies = [p p bien_formees est_vrai(p)]
copies = [p p phrases p CORPUS]
(bien_formees) / n, (vraies) / ((bien_formees), ), (copies) / n, ((phrases))
()
resultats = {}
ordre (, , , ):
bien, vraies, copies, distinctes = evaluer(ordre); resultats[ordre] = (bien, vraies, copies, distinctes)
()
resultats[][] > resultats[][] <
resultats[][] == resultats[][] ==
resultats[][] > resultats[][]
()
m2 = ModeleNgrammes(); m2.entrainer(CORPUS); r = random.Random()
fausses = []
(fausses) < :
p = m2.generer(r)
est_vrai(p) p fausses: fausses.append(p)
p fausses: (, p)
m3 = ModeleNgrammes(); m3.entrainer(CORPUS)
(): -(p * math.log2(p) _, p dist p > )
contexte = [, , , ]
()
T (, , , ):
d = m3.distribution(contexte, temperature=T); ()
entropie(m3.distribution(contexte, temperature=)) <= entropie(m3.distribution(contexte, temperature=)) <= entropie(m3.distribution(contexte, temperature=))
m3.entrainer([] * )
d_bas, d_haut = m3.distribution(contexte, temperature=), m3.distribution(contexte, temperature=)
d_bas[][] > d_haut[][]
top = m3.distribution(contexte, top_k=); noyau = m3.distribution(contexte, top_p=)
(, [(m, (p, )) m, p top], , [(m, (p, )) m, p noyau])
(top) == (noyau) <= (m3.distribution(contexte))
glouton = {m3.generer(random.Random(g), temperature=) g ()}
(, (glouton), , ({m3.generer(random.Random(g)) g ()}))
():
mots = Counter(texte.split()); vocab = {(m) + (,): n m, n mots.items()}; fusions = []
_ (nb_fusions):
paires = Counter()
symboles, n vocab.items():
a, b (symboles, symboles[:]): paires[(a, b)] += n
paires:
(a, b), _ = paires.most_common()[]; fusions.append((a, b)); nouveau = {}
symboles, n vocab.items():
res, i = [],
i < (symboles):
i < (symboles) - (symboles[i], symboles[i + ]) == (a, b): res.append(a + b); i +=
: res.append(symboles[i]); i +=
nouveau[(res)] = n
vocab = nouveau
fusions
():
symboles = (mot) + []
a, b fusions:
i, res = , []
i < (symboles):
i < (symboles) - (symboles[i], symboles[i + ]) == (a, b): res.append(a + b); i +=
: res.append(symboles[i]); i +=
symboles = res
symboles
TEXTE = * + *
fusions = apprendre_bpe(TEXTE, )
mot (, , , ):
()
(decouper(, fusions)) < (decouper(, fusions))
Lecture :
- Un modèle à contexte court (ordre 2) produit des phrases bien formées mais majoritairement fausses : il mélange les durées et les enseignants entre cours. Ce sont des hallucinations : plausibles, fluides, fausses — alors que tout son corpus d'entraînement était vrai.
- Un modèle à contexte long (ordre 5) est toujours fidèle… parce qu'il recopie son corpus : plus de variété. Fidélité et créativité sont en tension. Les vrais modèles évitent le recopiage grâce à leur taille et leur généralisation, mais conservent le risque de combler les trous par du plausible.
- La température modifie la forme de la distribution : basse, elle accentue le mot probable ; haute, elle l'aplatit (plus d'entropie, plus de variété, plus de risque). À température quasi nulle, le résultat devient presque déterministe.
- Top-k et top-p tronquent la distribution pour éviter les jetons très improbables.
- Le BPE découpe un mot courant (
réinitialisation) en moins de jetons qu'un mot rare (xylophone) : les mots rares coûtent plus cher en jetons.
✍️ À toi, avec aide (10 XP)
Tu disposes de la distribution suivante pour le jeton suivant, avec ses probabilités brutes :
{"semaines": 0.50, "jours": 0.25, "mois": 0.15, "heures": 0.07, "ans": 0.03}
- Calcule la distribution après application de la température T = 0,5 et T = 2 (p ∝ pᵀ⁻¹ normalisée).
- Calcule l'entropie (en bits) de chaque distribution (T = 0,5 ; 1 ; 2).
- Applique top-k = 2 puis top-p = 0,8 à la distribution d'origine (renormalise).
- Quelle probabilité a le mot « ans » dans chaque cas ? Dans quel cas risque-t-on le plus de générer un mot improbable ?
💡 Indice 1
Élève chaque probabilité à la puissance 1/T, puis renormalise.
💡 Indice 2
Entropie = −Σ p log₂ p.
💡 Indice 3
Top-p garde les mots les plus probables jusqu'à atteindre 0,8 de probabilité cumulée.
✅ Réponse
import math
P = {"semaines": 0.50, "jours": 0.25, "mois": 0.15, "heures": 0.07, "ans": 0.03}
def temperature(p, T):
w = {k: v ** (1 / T) for k, v in p.items()}; s = sum(w.values()); return {k: v / s for k, v in w.items()}
def entropie(p): return -sum(v * math.log2(v) for v in p.values())
for T in (0.5, 1, 2):
d = temperature(P, T); print(f"T = {T}: entropie {entropie(d):.2f} bits ; P(ans) = {d['ans']:.3f}")
def top_k(p, k):
garde = dict(sorted(p.items(), key=lambda x: -x[1])[:k]); s = sum(garde.values()); {a: b / s a, b garde.items()}
():
cumul, garde = , {}
m, v (p.items(), key= x: -x[]):
garde[m] = v; cumul += v
cumul >= seuil:
s = (garde.values()); {a: b / s a, b garde.items()}
(, {k: (v, ) k, v top_k(P, ).items()}, , {k: (v, ) k, v top_p(P, ).items()})
entropie(temperature(P, )) < entropie(P) < entropie(temperature(P, ))
top_k(P, ) top_p(P, ) temperature(P, )[] > P[]
🚀 À toi, en solo (20 XP)
Banc d'essai d'hallucination. Étends le petit modèle :
- ajoute à la base de faits une troisième relation (« le cours de X nécessite Y », avec 6 faits vrais) et adapte
est_vrai; - entraîne des modèles d'ordre 2 à 6 et mesure, pour chaque ordre, trois indicateurs sur 500 phrases : bien formées, fidèles (vraies parmi les bien formées), originales (bien formées, vraies, absentes du corpus) ;
- ajoute une défense simple : vérification contre la base — une phrase n'est conservée que si elle est vérifiée vraie ; mesure le rendement (part conservée) et la création de phrases vraies nouvelles ;
- montre qu'aucun ordre n'est à la fois très original et très fidèle dans ce petit corpus, et commente en quoi un modèle plus grand diffère ;
- écris une fonction
verifier(phrase)qui renvoievrai,fauxounon vérifiable(et teste-la sur 5 phrases).
✅ Pistes de correction
import random, re
from collections import Counter, defaultdict
DUREES = {"algorithmes": "dix", "structures": "huit", "réseaux": "huit", "systèmes": "douze", "sécurité": "six", "tests": "cinq"}
PROFS = {"algorithmes": "Ada", "structures": "Bob", "réseaux": "Cléo", "systèmes": "Dan", "sécurité": "Eve", "tests": "Flo"}
PREREQ = {"algorithmes": "mathématiques", "structures": "algorithmes", "réseaux": "systèmes", "systèmes": "algorithmes", "sécurité": "réseaux", "tests": "structures"}
CORPUS = ([f"le cours de {c} dure {DUREES[c]} semaines" for c in DUREES] + [f"le cours de {c} est enseigné par {PROFS[c]}" for c DUREES]
+ [ c DUREES])
():
motif, base ((, DUREES), (, PROFS), (, PREREQ)):
m = re.fullmatch(motif, phrase)
m: base.get(m.group()) == m.group()
:
(): .ordre, .c = ordre, defaultdict(Counter)
():
p phrases:
mots = [] * (.ordre - ) + p.split() + []
i (.ordre - , (mots)): .c[(mots[i - .ordre + :i])][mots[i]] +=
():
mots = [] * (.ordre - )
(mots) < :
cnt = .c[(mots[-(.ordre - ):])]
mot = rng.choices((cnt), (cnt.values()))[]
mot == :
mots.append(mot)
.join(m m mots m != )
()
ordre (, , , , ):
m = Modele(ordre); m.entrainer(CORPUS); rng = random.Random(ordre)
phrases = [m.generer(rng) _ ()]
bien = [p p phrases verifier(p) != ]
vraies = [p p bien verifier(p) == ]
originales = [p p vraies p CORPUS]
()
tests = [, , , , ]
([verifier(t) t tests])
[verifier(t) t tests] == [, , , , ]
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Croire qu'une réponse fluide est vraie | L'hallucination est plausible et assurée | Vérifier tout détail précis (noms, nombres, références) |
| Confondre déterminisme et exactitude | Une température basse ne garantit pas la vérité | Vérification indépendante |
| Supposer que le modèle connaît vos données ou l'actualité | Réponses inventées ou périmées | Fournir les sources dans le contexte (mission 4) |
| Envoyer des données sensibles sans réfléchir | Fuite de confidentialité | Politique d'usage, redaction (mission 9) |
🐉 Mini-boss (40 XP)
Fiche d'évaluation d'un modèle jouet. Construis une « carte de modèle » de ton petit modèle à n-grammes :
- données d'entraînement (taille, source, couverture) et connaissances absentes ;
- paramètres de génération et leur effet mesuré (température 0,2 / 1 / 2 ; top-k ; top-p) sur la fidélité, la variété et la longueur ;
- taux d'hallucination selon l'ordre (2 à 6) et le type de fait (durée, enseignant, prérequis) ;
- limites documentées : contexte, nouveauté, sensibilité à la formulation ;
- une procédure de vérification (source de vérité) et son rendement ;
- une recommandation d'usage : ce pour quoi le modèle est adapté (reformuler, proposer), ce pour quoi il ne l'est pas (affirmer un fait), avec la règle de vérification associée ;
- 5 lignes pour expliquer à un collègue non technicien pourquoi « il a dit que c'était vrai avec assurance » ne prouve rien.
✅ Pistes de correction
Un bon travail : tableau des taux d'hallucination par ordre et par type de fait (les faits dont la source est éloignée du jeton à prédire — par exemple l'enseignant — sont hallucinés davantage que ceux qui sont adjacents), effet de la température documenté, vérification contre une base et rendement, recommandations d'usage claires. L'explication au collègue insiste sur la distinction plausibilité contre véracité et sur la règle : toute affirmation factuelle d'un modèle est une hypothèse jusqu'à vérification indépendante.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un modèle de langage produit un texte en :
- A. tirant successivement le jeton suivant selon une distribution de probabilités
- B. consultant une base de faits garantie exacte
- C. copiant des pages web en direct
2. Une hallucination est :
- A. une erreur de syntaxe
- B. une sortie plausible et fluide mais fausse ou non fondée
- C. un message de refus
3. Une température plus élevée :
- A. rend le modèle plus exact
- B. supprime les hallucinations
- C. rend la distribution plus plate : plus de variété et plus de risque
4. 🔁 Révision HEF-150, mission 10 : Une prévision est bien calibrée quand :
- A. les événements annoncés à 70 % se réalisent environ 70 % du temps
- B. tous les événements annoncés se réalisent
- C. les probabilités annoncées sont toujours de 50 %
5. 🔁 Révision HEF-150, mission 10 : Dans une décision de continuer ou d'arrêter, le coût déjà dépensé :
- A. est l'argument principal
- B. ne doit pas entrer dans la comparaison des options futures
- C. doit être doublé
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quelle réponse d'IA as-tu déjà acceptée sans la vérifier, et qu'aurais-tu perdu si elle avait été fausse ?
- Pour quelles tâches de ton travail une erreur de l'IA est-elle bon marché à détecter ?
🎒 À retenir
- Un modèle prédit le jeton suivant : plausibilité, pas véracité.
- Jetons, température, top-k, top-p : le tirage n'est pas déterministe.
- Hallucination = comblement plausible ; fluide donc dangereuse.
- Contexte fini, connaissances datées, sensibilité à la formulation.
- Générer puis vérifier : la sortie est une proposition, jamais une preuve.
flowchart LR
T(["Modèles génératifs et limites"])
T --> R1["1. Un modèle prédit le jeton suivant : plausibilité, pas véracité."]
T --> R2["2. Jetons, température, top-k, top-p : le tirage n'est pas déterministe."]
T --> R3["3. Hallucination = comblement plausible ; fluide donc dangereuse."]
T --> R4["4. Contexte fini, connaissances datées, sensibilité à la formulation."]
T --> R5["5. Générer puis vérifier : la sortie est une proposition, jamais une…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Explorateur des modèles
Mission 02 — Prompt engineering orienté tâche →
HEF-160 — IA et augmentation humaine

