Module L27 · Partie K · Ingénierie de l’IA

Les grands modèles de langue : de la prédiction du token suivant à l’assistant.

Un LLM est un transformer décodeur (L25) entraîné à prédire le token suivant sur des milliers de milliards de tokens, puis aligné pour suivre des consignes. Ce chapitre couvre la chaîne complète : tokenisation (BPE), pré-entraînement et ses données, affinage supervisé, RLHF et DPO, décodage, capacités émergentes et limites (hallucinations, raisonnement, mémoire), coûts d’inférence, quantification, et exécution locale — avec la vue mathématique (vraisemblance, entropie, gradient de politique) et la vue informatique (mémoire, débit, latence).

Durée : 4 séances · Prérequis : L11, L15, L16, L25. Objectifs : implémenter BPE ; expliquer SFT/RLHF/DPO avec leurs équations ; échantillonner correctement ; quantifier un modèle ; faire tourner un LLM local et mesurer ; lire InstructGPT, DPO, LLaMA, GPT-4 report.

Ce que vous saurez faire à la fin

Coder un tokeniseur BPE et calculer la perplexité d’un modèle.
Écrire la fonction objectif de SFT, la récompense de RLHF et la perte de DPO, et expliquer pourquoi DPO évite le modèle de récompense.
Choisir température, top-p, pénalités ; comprendre la génération spéculative.
Estimer mémoire et débit d’un modèle en fp16/int8/int4 et le servir localement.

Fiche de cours · Définitions

Définitions

Définition (modèle de langue). Une loi de probabilité sur les suites de tokens, factorisée p_θ(x₁…x_n) = Π_t p_θ(x_t | x_<t). Entraîné par maximum de vraisemblance : minimiser −Σ log p_θ(x_t | x_<t) (entropie croisée). Perplexité = exp(perte moyenne par token) : nombre effectif de choix « équiprobables » à chaque position.

Définition (tokenisation BPE). Byte-Pair Encoding : partir des octets (256 symboles), fusionner itérativement la paire la plus fréquente en un nouveau symbole, jusqu’à un vocabulaire de taille V (32 k–256 k). Un texte est ensuite découpé en appliquant les fusions dans l’ordre appris. Un token ≈ 0,75 mot en anglais, moins en français.

Définition (pré-entraînement, SFT, alignement). Pré-entraînement : token suivant sur un corpus web filtré + code + livres. SFT (supervised fine-tuning) : même perte sur des paires (instruction, réponse) écrites par des humains. Alignement par préférences : à partir de comparaisons humaines (réponse A préférée à B), RLHF (modèle de récompense + PPO) ou DPO (optimisation directe).

Définition (RLHF). Entraîner un modèle de récompense r_φ(x, y) sur les préférences (modèle de Bradley-Terry), puis optimiser la politique π_θ par gradient de politique (PPO, L16) pour maximiser E[r_φ] − β·KL(π_θ ‖ π_ref), la pénalité KL empêchant de s’éloigner du modèle SFT.

Définition (DPO). Direct Preference Optimization : réécrit l’objectif RLHF comme une classification directe des paires préférées, sans modèle de récompense ni échantillonnage.

Définition (décodage). Glouton, échantillonnage à température T, top-k, top-p (nucleus), pénalité de répétition, recherche en faisceau ; génération spéculative : un petit modèle propose k tokens, le grand les vérifie en un passage.

Définition (hallucination). Sortie fluide et confiante mais fausse ou non fondée. Cause structurelle : le modèle optimise la plausibilité, pas la vérité ; il n’a pas de représentation de « je ne sais pas » sauf si on la lui apprend.

Définition (quantification). Représenter les poids sur moins de bits (int8, int4) avec des facteurs d’échelle par groupe : mémoire ÷2–4, débit ×2–3, perte de qualité faible si la méthode est calibrée (GPTQ, AWQ, GGUF k-quants).

Fiche de cours · Formules

Formules à connaître

Perte de pré-entraînement : L(θ) = −(1/N) Σ_t log p_θ(x_t | x_<t) ; perplexité PPL = e^L ; en bits par octet : L/(ln 2 · octets/token)

Bradley-Terry : P(y_w ≻ y_l | x) = σ(r(x, y_w) − r(x, y_l)) ; perte du modèle de récompense : −log σ(r_φ(x, y_w) − r_φ(x, y_l))

Objectif RLHF : max_θ E_{x, y∼π_θ}[r_φ(x, y)] − β·E_x[KL(π_θ(·|x) ‖ π_ref(·|x))]

Solution analytique : π*(y|x) = π_ref(y|x)·exp(r(x, y)/β)/Z(x) ⇒ r(x, y) = β log[π*(y|x)/π_ref(y|x)] + β log Z(x)

DPO : L = −E[log σ(β log(π_θ(y_w|x)/π_ref(y_w|x)) − β log(π_θ(y_l|x)/π_ref(y_l|x)))]

Température : p_T(k) ∝ p(k)^1/T ; top-p : plus petit ensemble de tokens de masse ≥ p, renormalisé

Mémoire des poids = N × bits/8 : 7B → 14 Go (fp16), 7 Go (int8), 3,5 Go (int4) ; + cache KV (L25) + activations

Débit en lot de 1 ≈ bande passante mémoire / taille des poids ; en lot de B : jusqu’à B fois plus (calcul partagé) tant que le calcul ne sature pas

Génération spéculative : k tokens proposés, acceptés avec probabilité min(1, p_grand/p_petit) ; distribution finale exactement celle du grand modèle

LoRA : W′ = W + BA avec B ∈ ℝ^d×r, A ∈ ℝ^r×d, r ≪ d ; paramètres entraînés 2dr au lieu de d² (r = 16, d = 4096 : 0,8 % des poids)

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire

Théorème 1 (la perte de pré-entraînement est une entropie croisée, bornée par l’entropie du langage). E_{x∼p_vrai}[−log p_θ(x)] = H(p_vrai) + KL(p_vrai ‖ p_θ) ≥ H(p_vrai).

−Σ p log q = −Σ p log p + Σ p log(p/q) = H(p) + KL(p ‖ q), et KL ≥ 0 (inégalité de Gibbs : log est concave, Jensen donne Σ p log(q/p) ≤ log Σ q = 0). La perte minimale est l’entropie du langage lui-même (≈ 1 bit par caractère en anglais selon Shannon) — le terme E des lois d’échelle (L25) en est l’estimation : même un modèle infini ne descend pas sous ≈ 1,7 nats/token sur le web. Lire une perte, c’est mesurer une divergence KL au vrai langage.

Théorème 2 (DPO : la récompense implicite). Le maximum de l’objectif RLHF avec pénalité KL est π*(y|x) ∝ π_ref(y|x)·exp(r(x, y)/β). Par conséquent r s’exprime en fonction de π* et de π_ref, et la perte de Bradley-Terry sur les préférences devient une perte directe sur π_θ (la perte DPO), sans modèle de récompense.

Pour x fixé, maximiser E_y∼π[r(x, y)] − β KL(π ‖ π_ref) = −β E_y∼π[log π(y|x) − log π_ref(y|x) − r(x,y)/β] = −β KL(π ‖ π̃) + β log Z(x), où π̃(y|x) = π_ref(y|x)e^r/β/Z(x) est une loi normalisée. La KL est minimale (nulle) pour π = π̃ : c’est π*. Inversons : r(x, y) = β log(π*(y|x)/π_ref(y|x)) + β log Z(x). Dans la différence r(x, y_w) − r(x, y_l) du modèle de Bradley-Terry, log Z(x) s’annule ; en remplaçant π* par la politique paramétrée π_θ, la perte −log σ(r_w − r_l) devient exactement la perte DPO. On optimise donc directement π_θ par descente de gradient sur des paires — stable, sans PPO. Le gradient pondère chaque paire par σ(r̂_l − r̂_w) : les paires que le modèle classe mal comptent plus.

Théorème 3 (la génération spéculative est exacte). Si le petit modèle propose y ∼ q et que l’on accepte avec probabilité min(1, p(y)/q(y)), en rééchantillonnant sinon selon norm(max(0, p − q)), le token final suit exactement p.

P(token = y) = q(y)·min(1, p(y)/q(y)) + P(rejet)·(p(y) − q(y))⁺/Σ_z(p(z) − q(z))⁺. Le premier terme vaut min(q(y), p(y)). P(rejet) = 1 − Σ_z min(q(z), p(z)) = Σ_z (p(z) − q(z))⁺ (car Σ p = Σ q = 1). Donc P(y) = min(q, p)(y) + (p − q)⁺(y) = p(y). Le gain : k tokens du petit modèle sont vérifiés en un passage du grand (parallèle sur la séquence, L15 Théorème 4) ; si le taux d’acceptation est α, on obtient ≈ (1 − α^k+1)/(1 − α) tokens par passage du grand modèle, jusqu’à 2–3× d’accélération quand la génération est limitée par la bande passante.

Théorème 4 (erreur de quantification uniforme). Quantifier des poids de plage [−a, a] sur b bits avec un pas Δ = 2a/(2^b − 1) introduit une erreur de variance Δ²/12 par poids ; l’erreur relative sur une sortie wᵀx est ≈ Δ/(√12·σ_w), indépendante de la dimension.

Erreur uniforme sur [−Δ/2, Δ/2] (L18, Théorème 6) : variance Δ²/12. Pour y = Σ w_ix_i, l’erreur Σ ε_ix_i a une variance (Δ²/12)Σ x_i², et y a une variance ≈ σ_w²Σ x_i² ; le rapport des écarts-types est Δ/(√12σ_w). Pour des poids gaussiens (σ_w ≈ a/3) en int4 (15 pas) : Δ = 2a/15, rapport ≈ (2/15)·3/3,46 ≈ 0,115 — 11 % de bruit relatif par couche, trop pour être naïf : d’où les facteurs d’échelle par groupe de 32–128 poids (a locale, plus petite), la protection des poids « saillants » (AWQ) et la compensation d’erreur (GPTQ), qui ramènent la dégradation de perplexité sous 1–2 %.

01 / Tokeniser

BPE depuis zéro, et ce que cela change pour le modèle

from collections import Counter
texte = ("le robot avance puis le robot tourne. le lidar mesure la distance ; la distance est grande. " * 6 + "les robots avancent et les lidars mesurent. ") * 2
def bpe_apprendre(texte, n_fusions):
    mots = Counter(tuple(m) + ("</w>",) for m in texte.split())      # chaque mot : suite de caractères + marqueur de fin
    fusions = []
    for _ in range(n_fusions):
        paires = Counter()
        for mot, f in mots.items():
            for a, b in zip(mot, mot[1:]): paires[(a, b)] += f
        if not paires: break
        (a, b), _ = paires.most_common(1)[0]; fusions.append((a, b))
        def fusionner(mot):
            out, i = [], 0
            while i < len(mot):
                if i < len(mot) - 1 and mot[i] == a and mot[i + 1] == b: out.append(a + b); i += 2
                else: out.append(mot[i]); i += 1
            return tuple(out)
        mots = Counter({fusionner(m): f for m, f in mots.items()})
    return fusions
def bpe_encoder(mot, fusions):
    s = list(mot) + ["</w>"]
    for a, b in fusions:                                              # appliquer les fusions dans l'ordre appris
        i = 0
        while i < len(s) - 1:
            if s[i] == a and s[i + 1] == b: s[i:i + 2] = [a + b]
            else: i += 1
    return s
fusions = bpe_apprendre(texte, 30)
print("premières fusions :", fusions[:12])
for mot in ("robot", "robots", "distance", "lidars", "avancent", "inconnu"):
    print(f"{mot:10s} → {bpe_encoder(mot, fusions)}")
# Compression : caractères par token
toks = sum(len(bpe_encoder(m, fusions)) for m in texte.split()); print(f"\n{len(texte)} caractères → {toks} tokens ({len(texte)/toks:.2f} car./token)")

Conséquences : un mot rare est éclaté en morceaux (« inconnu » → plusieurs tokens) ; les nombres sont découpés bizarrement (« 12345 » ≠ « 123 » + « 45 » selon les fusions) — d’où les faiblesses en arithmétique ; le français coûte ≈ 1,5× plus de tokens que l’anglais avec un vocabulaire appris sur de l’anglais ; et le modèle ne voit jamais de lettres : « combien de r dans strawberry » est une question sur des tokens qu’il ne peut pas décomposer.

02 / Aligner

De SFT à DPO : les trois pertes, implémentées sur un modèle jouet

import numpy as np
rng = np.random.default_rng(0)
# Modèle jouet : politique sur 6 "réponses" possibles à une question fixe, paramétrée par des logits theta (softmax).
# 1) SFT : maximiser log p(réponse démontrée) ; 2) modèle de récompense Bradley-Terry ; 3) DPO directement sur les préférences.
V = 6; noms = ["exacte+citée", "exacte", "vague", "fausse+confiante", "refus", "hors-sujet"]
def softmax(z): e = np.exp(z - z.max()); return e / e.sum()
theta_ref = np.zeros(V)                                            # modèle "pré-entraîné" : uniforme
# --- SFT sur une démonstration humaine ("exacte") ---
theta = theta_ref.copy()
for _ in range(200):
    p = softmax(theta); g = -p; g[1] += 1; theta += 0.3 * g          # ∇ log p(y=1) = e_1 − p
p_sft = softmax(theta); print("après SFT   :", dict(zip(noms, p_sft.round(2))))
# --- Préférences humaines : paires (préférée, rejetée) ---
prefs = [(0, 1), (0, 2), (1, 2), (4, 3), (1, 3), (0, 3), (2, 5), (4, 5)] * 5
# --- RLHF (a) : modèle de récompense r par Bradley-Terry ---
r = np.zeros(V)
for _ in range(300):
    for w, l in prefs:
        s = 1 / (1 + np.exp(r[w] - r[l])); r[w] += 0.05 * s; r[l] -= 0.05 * s   # ∇ log σ(r_w − r_l)
print("récompense  :", dict(zip(noms, r.round(2))))
# --- RLHF (b) : politique optimale analytique π* ∝ π_ref · exp(r/β) (Théorème 2) ---
beta = 0.5; p_rlhf = p_sft * np.exp(r / beta); p_rlhf /= p_rlhf.sum()
print("π* RLHF     :", dict(zip(noms, p_rlhf.round(2))))
# --- DPO : descente directe sur la perte −log σ(β(log π/π_ref)_w − β(log π/π_ref)_l), π_ref = SFT ---
theta = np.log(p_sft); ref = np.log(p_sft)
for _ in range(300):
    for w, l in prefs:
        lp = np.log(softmax(theta)); h = beta * ((lp[w] - ref[w]) - (lp[l] - ref[l])); s = 1 / (1 + np.exp(h))
        g = np.zeros(V); p = softmax(theta); gw = -p; gw[w] += 1; gl = -p; gl[l] += 1     # ∇ log π(w), ∇ log π(l)
        theta += 0.05 * s * beta * (gw - gl)
p_dpo = softmax(theta); print("DPO         :", dict(zip(noms, p_dpo.round(2))))
print("\nLes trois étapes déplacent la masse vers 'exacte+citée' et le refus honnête, loin de 'fausse+confiante' ; DPO retrouve π* sans modèle de récompense.")

03 / Décoder

Échantillonnage : température, top-p, pénalité — et la génération spéculative vérifiée

import numpy as np
rng = np.random.default_rng(3)
logits = np.array([3.0, 2.5, 2.0, 1.0, 0.5, 0.0, -1.0, -2.0]); toks = list("abcdefgh")
def softmax(z): e = np.exp(z - z.max()); return e / e.sum()
def entropie(p): p = p[p > 0]; return -(p * np.log2(p)).sum()
print("T     entropie (bits)   p(a)   p(h)")
for T in (0.1, 0.5, 1.0, 2.0, 10.0):
    p = softmax(logits / T); print(f"{T:4.1f}   {entropie(p):6.2f}         {p[0]:.3f}  {p[-1]:.4f}")
def top_p(p, seuil):
    o = np.argsort(-p); c = np.cumsum(p[o]); k = np.searchsorted(c, seuil) + 1; q = np.zeros_like(p); q[o[:k]] = p[o[:k]]; return q / q.sum()
p = softmax(logits); print("\ntop-p 0,9 :", dict(zip(toks, top_p(p, 0.9).round(3))))
# Génération spéculative (Théorème 3) : vérifier empiriquement que la loi finale est celle du grand modèle
p_grand = softmax(logits); q_petit = softmax(logits + rng.normal(0, 1.0, len(logits)))   # petit modèle : approximatif
def speculatif():
    y = rng.choice(len(p_grand), p=q_petit)
    if rng.random() < min(1, p_grand[y] / q_petit[y]): return y
    resid = np.maximum(0, p_grand - q_petit); return rng.choice(len(p_grand), p=resid / resid.sum())
N = 40000; comptes = np.bincount([speculatif() for _ in range(N)], minlength=len(p_grand)) / N
print("\nfréquences spéculatif :", comptes.round(3)); print("p du grand modèle      :", p_grand.round(3))
print("taux d'acceptation :", np.sum(np.minimum(p_grand, q_petit)).round(3), "→ écart max :", np.abs(comptes - p_grand).max().round(4))

Règles pratiques : code et extraction → T ≈ 0–0,3 ; rédaction → 0,7 ; brainstorming → 1,0 avec top-p 0,95. Une pénalité de répétition > 1,2 casse le code (les accolades se répètent légitimement). La graine ne suffit pas à la reproductibilité : le calcul parallèle sur GPU n’est pas déterministe au bit près.

04 / Servir

Vue informatique : mémoire, débit, coût — et faire tourner un LLM chez soi

def budget(N_params, bits, L=32, h_kv=8, dk=128, ctx=4096, bw=1e12, lot=1, gpu_go=24):
    poids = N_params * bits / 8 / 1e9; cache = 2 * L * ctx * h_kv * dk * 2 / 1e9 * lot          # cache KV en fp16
    tps = bw / (N_params * bits / 8)                                                          # tokens/s (lot 1, limité par la mémoire)
    return poids, cache, poids + cache, tps
print(f"{'modèle':22s} {'poids':>7s} {'cache':>7s} {'total':>7s} {'ok 24 Go?':>10s} {'tok/s (1 To/s)':>15s}")
for nom, N, bits, L, hkv in (("7B fp16", 7e9, 16, 32, 32), ("7B int4", 7e9, 4, 32, 32), ("8B int4 (GQA)", 8e9, 4, 32, 8), ("70B int4 (GQA)", 70e9, 4, 80, 8), ("70B int2 (GQA)", 70e9, 2, 80, 8)):
    p, c, t, tps = budget(N, bits, L, hkv); print(f"{nom:22s} {p:6.1f}G {c:6.1f}G {t:6.1f}G {'oui' if t < 24 else 'non':>10s} {tps:15.0f}")
print("\nCoût API (ordre de grandeur 2025) : 0,1–1 €/M tokens (petits), 2–15 €/M (grands) ; un RAG à 3 000 tokens/requête × 10 000 requêtes/jour = 30 M tokens/jour.")
print("Local : électricité ~0,3 kWh/h de GPU ; un 8B int4 sur RTX 4090 ≈ 80–120 tokens/s en lot 1, > 1 000 tokens/s en lot 32 (vLLM).")

Outil	Usage	Point fort
llama.cpp / Ollama	Inférence locale CPU/GPU, GGUF quantifié	Simplicité, tourne sur un portable
vLLM, TGI, SGLang	Serveur haut débit	PagedAttention (cache KV paginé), lots continus, spéculatif
Hugging Face transformers + PEFT	Affinage (LoRA, QLoRA)	Écosystème, modèles ouverts
bitsandbytes, GPTQ, AWQ, llama.cpp k-quants	Quantification	int8/int4 avec ≤ 1–2 % de perte
API (OpenAI, Anthropic, Mistral, Gemini)	Modèles frontières	Qualité ; coût variable ; données qui sortent

05 / Comprendre

Capacités, limites, et ce que la recherche en dit

Ce qui marche (et pourquoi)

Apprentissage en contexte : quelques exemples dans le prompt suffisent — mécanisme des têtes d’induction (L25) et méta-apprentissage implicite pendant le pré-entraînement.
Chaîne de raisonnement : « raisonne étape par étape » rallonge la séquence, donc le calcul disponible (limite TC⁰ de L25) ; les modèles « à raisonnement » (o1, R1) sont entraînés par RL à produire ces chaînes.
Code, traduction, résumé, extraction structurée : tâches où la vérification est possible ou la donnée abondante.
Outils : appeler une calculatrice, une recherche, du code (function calling) compense l’arithmétique et la connaissance figée.

Ce qui ne marche pas (et pourquoi)

Hallucinations : optimisation de la plausibilité ; calibration dégradée par le RLHF (GPT-4 report) ; remède partiel : RAG, citations, abstention apprise, vérification.
Arithmétique et comptage : tokenisation + profondeur bornée.
Connaissance figée : date de coupure ; RAG ou outils.
Sensibilité au prompt : reformuler change la réponse (L28 pour la mesurer).
Biais et sécurité : reflet du corpus ; jailbreaks ; injection de prompt (L26) ; fuite de données d’entraînement (mémorisation).
Coût et empreinte : GPT-4 ≈ 10⁵ fois le coût d’une requête de recherche classique.

Évaluer tout cela rigoureusement : chapitre L32 (métriques) — MMLU, GSM8K, HumanEval, MT-Bench, contamination, et pourquoi les classements publics trompent.

06 / Articles

Les articles à lire

Article	Contribution	À retenir
Sennrich et al., Neural Machine Translation of Rare Words with Subword Units (BPE), ACL 2016 — 1508.07909	BPE pour les sous-mots	Le tokeniseur est un choix de modélisation, pas un détail
Brown et al., Language Models are Few-Shot Learners (GPT-3), 2020 — 2005.14165	Apprentissage en contexte à l’échelle	Évaluation par prompts ; contamination discutée en annexe
Ouyang et al., Training language models to follow instructions (InstructGPT), 2022 — 2203.02155	SFT + modèle de récompense + PPO ; un 1,3B aligné préféré à GPT-3 175B	L’alignement vaut plus que la taille pour l’utilité perçue ; « alignment tax »
Bai et al., Constitutional AI, 2022 — 2212.08073	Préférences générées par le modèle selon des principes (RLAIF)	Réduire l’annotation humaine ; transparence des critères
Rafailov et al., Direct Preference Optimization, NeurIPS 2023 — 2305.18290	RLHF sans RL : perte de classification sur les paires	Théorème 2 ; standard pour les modèles ouverts
Wei et al., Chain-of-Thought Prompting, NeurIPS 2022 — 2201.11903	Le raisonnement explicite émerge avec la taille	Lien avec la profondeur de calcul
Hu et al., LoRA, ICLR 2022 — 2106.09685 ; Dettmers et al., QLoRA, 2023 — 2305.14314	Affinage à faible rang ; sur base quantifiée en 4 bits	Affiner un 65B sur un GPU de 48 Go
Leviathan et al., Fast Inference from Transformers via Speculative Decoding, ICML 2023 — 2211.17192	Génération spéculative exacte	Théorème 3
Kwon et al., Efficient Memory Management for LLM Serving (vLLM, PagedAttention), SOSP 2023 — 2309.06180	Cache KV paginé comme une mémoire virtuelle	Débit ×2–4 en service
Frantar et al., GPTQ, 2022 — 2210.17323 ; Lin et al., AWQ, 2023 — 2306.00978	Quantification post-entraînement 4 bits précise	Théorème 4 et ses remèdes
OpenAI, GPT-4 Technical Report, 2023 — 2303.08774	Prédiction des performances par lois d’échelle ; calibration ; évaluations	Le RLHF dégrade la calibration (fig. 8) ; peu de détails techniques : lire ce qui manque
Carlini et al., Extracting Training Data from LLMs, 2021 — 2012.07805	Mémorisation et fuite de données	Données personnelles dans le corpus = risque

TP guidé

TP — Un LLM local, affiné, mesuré (6 h)

Servir. Installer Ollama ; ollama run llama3.1:8b ; mesurer tokens/s en lot 1 (fichier de 20 prompts, chronométrer) ; comparer q4_K_M et q8_0 : vitesse, mémoire, et 20 questions de culture générale notées à la main.
Tokeniser. Avec tiktoken ou le tokeniseur HF du modèle : compter les tokens d’un même texte en français, anglais, code, JSON ; expliquer les écarts ; trouver un mot découpé en 4 tokens.
Perplexité. Avec transformers, calculer la perplexité d’un petit modèle (GPT-2, Qwen-0.5B) sur (a) un texte Wikipédia, (b) un texte que vous avez écrit, (c) un texte aléatoire ; interpréter.
Affiner par LoRA. PEFT + un jeu de 300 paires (instruction, réponse) dans votre domaine (générées puis relues à la main) ; r = 16, 3 époques, sur GPU (Colab suffit). Évaluer avant/après sur 50 questions tenues à l’écart, avec un juge et 10 vérifications humaines. Observer l’oubli : la performance sur des questions générales a-t-elle baissé ?
DPO. Construire 200 paires de préférences (réponse concise et citée vs verbeuse), entraîner par DPO (TRL), mesurer la longueur moyenne et la préférence d’un juge avant/après.
Livrable. Dépôt avec mesures de débit, tableau de perplexités, adaptateurs LoRA, résultats avant/après avec IC, et une page « ce que l’alignement a changé et ce qu’il a cassé ».

Exercices

Exercices auto-corrigés

Exercice 1 — Perplexité et entropie croisée

Écrivez perplexite(probas) (probas : liste des probabilités assignées par le modèle à chaque vrai token) et vérifiez : un modèle parfait a une perplexité de 1 ; un modèle uniforme sur V tokens a V ; la perplexité est la moyenne géométrique des inverses.

Correction

def perplexite(probas): return float(np.exp(-np.mean(np.log(probas))))

Exercice 2 — Gradient de la perte DPO

Pour une paire (w, l), avec h = β[(log π_θ(w) − log π_ref(w)) − (log π_θ(l) − log π_ref(l))], la perte est −log σ(h). Écrivez perte_dpo(theta, ref, w, l, beta) et grad_dpo(...) pour une politique softmax sur V réponses (theta : logits), et vérifiez le gradient par différences finies.

Correction

def perte_dpo(theta, ref, w, l, beta):
    lp, lr = np.log(softmax(theta)), np.log(softmax(ref)); h = beta * ((lp[w] - lr[w]) - (lp[l] - lr[l]))
    return float(np.log(1 + np.exp(-h)))
def grad_dpo(theta, ref, w, l, beta):
    p = softmax(theta); lp, lr = np.log(p), np.log(softmax(ref)); h = beta * ((lp[w] - lr[w]) - (lp[l] - lr[l]))
    s = 1 / (1 + np.exp(h))                           # = 1 − σ(h)
    gw = -p.copy(); gw[w] += 1; gl = -p.copy(); gl[l] += 1
    return -s * beta * (gw - gl)

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Quantification par groupes

Implémentez quantifier(w, bits, groupe) qui découpe w en groupes consécutifs, calcule pour chacun un facteur d’échelle a = max|w| et quantifie sur 2^bits − 1 niveaux symétriques, et dequantifier. Vérifiez que l’erreur relative RMS diminue quand le groupe rétrécit, et qu’elle est ≈ Δ/(√12·σ) (Théorème 4) pour un grand groupe.

Correction

def quantifier(w, bits, groupe):
    n = (2 ** bits - 1) // 2                                   # niveaux −n..n (int4 : −7..7)
    W = w.reshape(-1, groupe); pas = np.abs(W).max(1) / n + 1e-12   # une échelle (le pas Δ) par groupe
    return np.clip(np.round(W / pas[:, None]), -n, n).astype(int), pas
def dequantifier(q, echelles, groupe): return (q * echelles[:, None]).reshape(-1)

Ce que stocke un fichier GGUF/GPTQ : les entiers sur 4 bits et un pas (fp16) par groupe de 32 à 128 poids — soit ≈ 4,5 bits par poids en moyenne.

Exercice 4 — Top-p et budget de contexte

a) Écrivez top_p(p, seuil) renvoyant les indices retenus (masse cumulée ≥ seuil, plus petit ensemble). b) Écrivez tokens_max_reponse(ctx, prompt_tokens, marge=64) et cout(tokens_in, tokens_out, prix_in, prix_out) (prix par million).

Correction

def top_p(p, seuil):
    o = np.argsort(-p); c = np.cumsum(p[o]); k = int(np.searchsorted(c, seuil - 1e-12)) + 1; return list(o[:k])
def tokens_max_reponse(ctx, prompt_tokens, marge=64): return max(0, ctx - prompt_tokens - marge)
def cout(tokens_in, tokens_out, prix_in, prix_out): return (tokens_in * prix_in + tokens_out * prix_out) / 1e6

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Pourquoi la pénalité KL est-elle indispensable dans l’objectif RLHF ? Que se passe-t-il avec β → 0 ?

Correction. Le modèle de récompense r_φ n’est qu’une approximation apprise sur un nombre fini de comparaisons ; hors de la distribution des réponses vues, il est arbitraire. Sans KL (β → 0), la politique optimale concentre toute sa masse sur les réponses qui maximisent r_φ, y compris ses erreurs : c’est le reward hacking (réponses longues, flatteuses, formules répétées, ou incohérentes qui exploitent une faille du juge) — loi de Goodhart. La KL ancre π_θ à π_ref (SFT), là où r_φ est fiable ; β règle le compromis. Le Théorème 2 montre que la solution reste proportionnelle à π_ref : une réponse impossible pour le modèle SFT reste impossible.

Exercice 2. Un modèle de 70 B en int4 avec GQA (8 têtes KV, d_k = 128, 80 couches) doit servir 16 conversations simultanées de 8 000 tokens sur un GPU de 80 Go. Est-ce possible ? Quel est le débit approximatif si la bande passante est de 3 To/s ?

Correction. Poids : 70·10⁹ × 0,5 octet = 35 Go. Cache KV par token : 2 × 80 × 8 × 128 × 2 octets = 328 Ko ; par conversation de 8 000 tokens : 2,6 Go ; pour 16 : 42 Go. Total 77 Go — juste (activations et fragmentation : PagedAttention nécessaire) ; en pratique 12 conversations. Débit : chaque étape de décodage lit les 35 Go de poids une fois pour les 16 requêtes (lot) : 3·10¹²/35·10⁹ ≈ 86 étapes/s × 16 ≈ 1 370 tokens/s au total, ≈ 86 tokens/s par utilisateur, tant que le calcul (2 × 70·10⁹ × 16 = 2,2 TFLOP par étape, ≈ 2 ms sur 1 PFLOP/s) reste inférieur au temps de lecture (12 ms) — c’est le cas ; le lot est donc « gratuit » jusqu’à ≈ 6× plus grand.

Exercice 3. Un assistant RLHF est moins bien calibré qu’un modèle de base (GPT-4 report). Expliquer ce que signifie « calibré » et pourquoi l’alignement dégrade la calibration.

Correction. Calibré : parmi les réponses auxquelles le modèle assigne une probabilité 0,7, environ 70 % sont correctes (diagramme de fiabilité, L32). Le modèle de base, entraîné par maximum de vraisemblance, est une estimation de densité : ses probabilités reflètent les fréquences du corpus, donc sont bien calibrées. Le RLHF optimise une récompense de préférence humaine, qui favorise les réponses assurées et tranchées (les humains préfèrent la confiance) : le modèle apprend à concentrer sa masse, indépendamment de sa connaissance réelle — sur-confiance. Remèdes : température de calibration, entraînement explicite à l’abstention et à l’expression d’incertitude, ou lire les probabilités du modèle de base pour la décision et laisser le modèle aligné pour la formulation.

Vérification

Qu’est-ce que DPO supprime par rapport au RLHF classique ?

Deux questions supplémentaires

1. Pourquoi les LLM comptent-ils mal les lettres ? Ils voient des tokens BPE, pas des caractères ; « strawberry » est un ou deux tokens opaques.

2. Pourquoi la génération en lot est-elle presque gratuite ? Le décodage est limité par la lecture des poids ; un lot partage cette lecture entre les requêtes.

Référence

Les mots à retenir

Mot	Définition
BPE	Tokenisation par fusions de paires fréquentes ; vocabulaire de 32 k–256 k.
Perplexité	exp(entropie croisée moyenne) ; nombre effectif de choix par token.
SFT	Affinage supervisé sur des démonstrations.
RLHF	Modèle de récompense + gradient de politique avec pénalité KL.
DPO	Optimisation directe des préférences, sans modèle de récompense.
Température / top-p	Contrôle de l’entropie de l’échantillonnage.
Génération spéculative	Petit modèle propose, grand vérifie ; loi exacte.
Quantification	Poids en int8/int4 par groupes avec échelles ; mémoire ÷2–4.
LoRA	Affinage par matrices de rang faible ajoutées aux poids.

Suite

Le modèle est là. Comment lui parler pour obtenir ce que vous voulez — et le prouver.

Le prompt engineering n’est pas de la magie : c’est du conditionnement, mesurable. Chapitre suivant : techniques, mathématiques du few-shot, et surtout l’évaluation systématique des prompts.

← L26 Sommaire L28 : prompt engineering →