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

RAG : donner au modèle vos documents, et prouver qu’il s’en sert.

Un LLM ne connaît que son corpus d’entraînement, figé, et invente quand il ne sait pas. La génération augmentée par la recherche (Retrieval-Augmented Generation) recherche d’abord les passages pertinents dans vos documents, puis les fournit au modèle qui répond en les citant. Ce chapitre construit chaque brique — découpage, plongements, index, recherche hybride, reclassement, génération, citations — en code exécutable, avec les mathématiques de la recherche d’information (BM25, similarité cosinus, ANN) et les métriques qui disent si ça marche.

Durée : 4 séances · Prérequis : L08 (bases de données), L13, L15, L25. Objectifs : implémenter un RAG complet ; comprendre BM25 et les plongements denses ; construire un index approximatif (HNSW, idée) ; évaluer recherche et génération séparément ; connaître les modes d’échec et les articles.

Ce que vous saurez faire à la fin

Découper un corpus, l’indexer (lexical + dense), rechercher, reclasser, générer avec citations.
Calculer rappel@k, MRR, nDCG pour la recherche ; fidélité et pertinence pour la réponse.
Diagnostiquer un RAG qui échoue : découpage, rappel, contexte, modèle.
Lire RAG (Lewis 2020), DPR, ColBERT, HNSW, RAGAS.

Fiche de cours · Définitions

Définitions

Définition (recherche d’information). Étant donné une requête q et un corpus de documents D, renvoyer les k documents les plus pertinents. Pertinence : jugement humain (binaire ou gradué) ; le système renvoie un classement.

Définition (RAG). Pipeline : (1) ingestion : documents → morceaux (chunks) → représentations (index) ; (2) recherche : q → k morceaux ; (3) génération : prompt = consigne + morceaux + question → réponse avec citations. Variante : RAG itératif (plusieurs recherches), agentique (le modèle décide quand chercher).

Définition (recherche lexicale, BM25). Score fondé sur les mots communs entre q et d, pondérés par leur rareté (IDF) et saturés en fréquence (TF). Index inversé : mot → liste des documents. Exact sur les mots, aveugle aux synonymes.

Définition (recherche dense, plongement). Un encodeur (transformer encodeur, L25) envoie textes et requêtes dans ℝ^d ; score = similarité cosinus. Capte le sens, rate les termes rares (références, codes). Bi-encodeur : q et d encodés séparément (rapide, indexable) ; cross-encodeur : (q, d) encodés ensemble (précis, lent : pour reclasser les k premiers).

Définition (recherche approximative, ANN). Trouver les plus proches voisins parmi N vecteurs en sous-linéaire : HNSW (graphe navigable hiérarchique), IVF (partition en cellules + recherche dans les plus proches), PQ (quantification produit). Compromis rappel / vitesse / mémoire.

Définition (hybride, RRF). Fusionner lexical et dense : Reciprocal Rank Fusion, score(d) = Σ_listes 1/(60 + rang(d)).

Définition (métriques de recherche). Rappel@k : fraction des documents pertinents dans les k premiers. Précision@k. MRR : moyenne de 1/rang du premier pertinent. nDCG@k : gain cumulé actualisé normalisé (pertinences graduées, positions pondérées par 1/log₂(rang + 1)).

Définition (métriques de génération en RAG). Fidélité (faithfulness) : la réponse est-elle soutenue par le contexte fourni ? Pertinence de la réponse : répond-elle à la question ? Pertinence du contexte : les morceaux fournis étaient-ils utiles ? Mesurées par juges humains ou par LLM-juge (L32).

Fiche de cours · Formules

Formules à connaître

BM25(q, d) = Σ_t∈q IDF(t) · tf(t,d)·(k₁ + 1) / (tf(t,d) + k₁·(1 − b + b·|d|/avgdl)), IDF(t) = ln((N − n_t + 0,5)/(n_t + 0,5) + 1) k₁ ≈ 1,2–2 (saturation), b ≈ 0,75 (normalisation par longueur)

Cosinus : cos(u, v) = uᵀv/(‖u‖‖v‖) ; vecteurs normalisés ⇒ produit scalaire ; distance euclidienne² = 2 − 2cos

Entraînement d’un bi-encodeur (contrastif, InfoNCE) : L = −log [e^s(q,d⁺)/τ / (e^s(q,d⁺)/τ + Σ_d⁻ e^s(q,d⁻)/τ)] — négatifs « durs » (BM25 proches mais non pertinents) essentiels

Rappel@k = |pertinents ∩ top-k| / |pertinents| ; MRR = (1/|Q|) Σ_q 1/rang_q ; DCG@k = Σ_i≤k (2^rel_i − 1)/log₂(i + 1), nDCG = DCG/IDCG

RRF(d) = Σ_{listes ℓ} 1/(k + rang_ℓ(d)), k = 60

Coût d’un contexte : tokens_prompt = consigne + k·taille_chunk + question ; latence ≈ recherche (ms) + préremplissage (∝ tokens_prompt) + génération (∝ tokens_réponse)

Recherche exacte : O(N·d) par requête ; HNSW : O(log N) en pratique ; mémoire index ≈ N·d·4 octets (float32) — 10⁷ vecteurs de dimension 768 : 31 Go, 8 Go en int8, 1 Go en PQ

Découpage : taille de chunk c tokens, chevauchement o ; nombre de chunks ≈ (T − o)/(c − o) pour T tokens de corpus

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

Démonstrations à savoir refaire

Théorème 1 (BM25 est une vraisemblance sous un modèle probabiliste). Sous le modèle binaire d’indépendance (les termes sont indépendants sachant la pertinence), le score optimal pour classer est Σ_t∈q∩d log [p_t(1 − u_t)/(u_t(1 − p_t))] où p_t = P(t ∈ d | pertinent), u_t = P(t ∈ d | non pertinent) ; avec p_t ≈ ½ et u_t ≈ n_t/N on obtient l’IDF.

Classer par P(R | d) croissant équivaut à classer par le rapport de vraisemblance P(d | R)/P(d | R̄) (Bayes, les a priori étant communs). Par indépendance, P(d | R) = Π_t∈d p_t Π_t∉d (1 − p_t) et de même avec u. Le log du rapport, en ne gardant que les termes qui dépendent de d et sont dans q (les autres sont constants ou ignorés), donne Σ_t∈q∩d log[p_t/u_t · (1 − u_t)/(1 − p_t)]. Sans information sur la pertinence, p_t = ½ annule le premier facteur ; u_t = n_t/N donne log((N − n_t)/n_t), l’IDF (avec les +0,5 de lissage). La partie TF de BM25 est une extension heuristique (modèle 2-Poisson de Robertson) : le poids d’un terme croît avec sa fréquence mais sature — un mot répété 20 fois ne vaut pas 20 fois plus.

Théorème 2 (la similarité cosinus des plongements normalisés est une recherche de plus proche voisin euclidien). Pour ‖u‖ = ‖v‖ = 1, ‖u − v‖² = 2 − 2uᵀv ; maximiser le cosinus = minimiser la distance euclidienne.

‖u − v‖² = ‖u‖² + ‖v‖² − 2uᵀv = 2 − 2uᵀv. Conséquence pratique : tous les index ANN (conçus pour la distance euclidienne ou le produit scalaire) s’appliquent aux plongements normalisés ; et une recherche exacte est un simple produit matrice-vecteur E·q, que NumPy fait à 10⁶ vecteurs × 768 en ~50 ms.

Théorème 3 (rappel@k borne la qualité du RAG). Si l’information nécessaire n’est pas dans les k morceaux fournis, la réponse correcte ne peut venir que de la mémoire du modèle (ou d’une hallucination). Donc : exactitude(RAG) ≤ rappel@k × P(réponse correcte | contexte présent) + (1 − rappel@k) × P(correcte sans contexte).

Décomposition par probabilités totales sur l’événement « le contexte contient la réponse ». Le second terme est la performance sans RAG (souvent faible sur des données privées) ; le premier est plafonné par le rappel. Conséquence méthodologique : mesurer la recherche seule (rappel@k sur un jeu de questions annotées) avant de toucher au modèle ; un RAG à 60 % de rappel ne dépassera pas ≈ 60–70 % d’exactitude quel que soit le LLM.

Théorème 4 (RRF est robuste aux échelles de scores). RRF ne dépend que des rangs, donc est invariant par toute transformation croissante des scores de chaque liste.

rang_ℓ(d) est inchangé par une fonction strictement croissante appliquée aux scores de la liste ℓ. BM25 (scores de 0 à ~30) et cosinus (de −1 à 1) ne sont pas comparables ; les combiner linéairement exige une normalisation fragile ; RRF évite le problème. Le k = 60 amortit l’influence des premiers rangs (1/61 vs 1/62 : la différence entre le 1er et le 2e est faible, ce qui favorise les documents présents dans plusieurs listes).

01 / Construire

Ingestion : découper intelligemment, puis indexer lexicalement (BM25 depuis zéro)

import re, math
from collections import Counter, defaultdict
corpus = {
 "manuel_robot.md": "Le robot R2 dispose de deux moteurs à courant continu commandés en PWM à 20 kHz. La tension nominale est de 12 V. Le courant maximal par moteur est de 3 A. Un fusible de 5 A protège l'alimentation. Le lidar RPLIDAR A1 tourne à 5,5 Hz et fournit 360 mesures par tour avec une portée de 12 m. Le firmware publie l'odométrie à 50 Hz sur le topic /odom. En cas de surchauffe, le contrôleur réduit le rapport cyclique à 50 %.",
 "procedure_maintenance.md": "Avant toute intervention, couper l'alimentation et attendre 30 secondes. Les batteries LiPo 3S doivent être stockées à 3,8 V par cellule. Remplacer le fusible uniquement par un modèle 5 A à fusion rapide. Nettoyer la vitre du lidar avec un chiffon microfibre sec. Vérifier le serrage des roues tous les 20 heures de fonctionnement.",
 "faq.md": "Q : le robot s'arrête après quelques minutes. R : vérifier la température du contrôleur ; au-delà de 70 °C le rapport cyclique est réduit. Q : l'odométrie dérive. R : recalibrer l'entraxe des roues et le diamètre. Q : quel est le rayon de braquage ? R : le robot tourne sur place, rayon nul.",
}
def decouper(texte, taille=40, chevauchement=10):
    """Découpe en phrases puis regroupe en morceaux de ~taille mots avec chevauchement (en mots)."""
    mots = texte.split(); morceaux = []; i = 0
    while i < len(mots):
        morceaux.append(" ".join(mots[i:i + taille])); i += taille - chevauchement
    return morceaux
chunks = [(doc, k, m) for doc, t in corpus.items() for k, m in enumerate(decouper(t))]
print(len(chunks), "morceaux ; exemple :", chunks[3])
def tokens(s): return re.findall(r"[a-zà-ÿ0-9]+", s.lower())
class BM25:
    def __init__(self, textes, k1=1.5, b=0.75):
        self.k1, self.b = k1, b; self.docs = [tokens(t) for t in textes]; self.N = len(textes)
        self.avgdl = sum(map(len, self.docs)) / self.N; self.tf = [Counter(d) for d in self.docs]
        self.df = Counter(t for d in self.docs for t in set(d))
        self.idf = {t: math.log((self.N - n + 0.5) / (n + 0.5) + 1) for t, n in self.df.items()}
    def score(self, q, i):
        s = 0.0; d = self.docs[i]
        for t in tokens(q):
            if t in self.tf[i]:
                f = self.tf[i][t]; s += self.idf[t] * f * (self.k1 + 1) / (f + self.k1 * (1 - self.b + self.b * len(d) / self.avgdl))
        return s
    def chercher(self, q, k=3): return sorted(range(self.N), key=lambda i: -self.score(q, i))[:k]
bm25 = BM25([m for _, _, m in chunks])
for q in ("Quel fusible utiliser ?", "Pourquoi le robot ralentit quand il chauffe ?", "fréquence du lidar"):
    print(f"\n{q}")
    for i in bm25.chercher(q, 2): print(f"  {bm25.score(q, i):5.2f}  [{chunks[i][0]} #{chunks[i][1]}] {chunks[i][2][:90]}…")

Le découpage est le premier levier : trop petit, on perd le contexte (« le rapport cyclique » de quoi ?) ; trop grand, on dilue et on paie des tokens. Chevaucher évite de couper une information en deux. En pratique : 200–500 tokens par morceau, chevauchement 10–20 %, et respecter les frontières (titres, paragraphes, tableaux).

01 / Construire

Plongements denses (jouet mais fidèle), recherche hybride, reclassement

import numpy as np, re
from collections import Counter
# Sans modèle pré-entraîné dans le navigateur, on simule un plongement "sémantique" : LSA (SVD sur TF-IDF) + synonymes.
# Sur PC : sentence-transformers (all-MiniLM, e5, bge) donne des vecteurs de 384-1024 dims avec le même code de recherche.
syn = {"chauffe": "temperature", "surchauffe": "temperature", "chaud": "temperature", "ralentit": "reduit", "vitesse": "rapport", "frequence": "hz", "tourne": "hz", "protection": "fusible"}
def tokens_sem(s): return [syn.get(t, t) for t in re.findall(r"[a-zà-ÿ0-9]+", s.lower())]
textes = [m for _, _, m in chunks]; vocab = sorted({t for m in textes for t in tokens_sem(m)}); idx = {t: i for i, t in enumerate(vocab)}
def tfidf(s, df, N):
    c = Counter(tokens_sem(s)); v = np.zeros(len(vocab))
    for t, f in c.items():
        if t in idx: v[idx[t]] = (1 + np.log(f)) * np.log(N / (1 + df.get(t, 0)))
    return v
df = Counter(t for m in textes for t in set(tokens_sem(m))); N = len(textes)
M = np.array([tfidf(m, df, N) for m in textes])
U, S, Vt = np.linalg.svd(M, full_matrices=False); kdim = 6
def plonger(s): v = tfidf(s, df, N) @ Vt[:kdim].T / S[:kdim]; n = np.linalg.norm(v); return v / n if n > 0 else v
E = np.array([plonger(m) for m in textes])                       # index dense : une matrice (N, kdim), normalisée
def dense(q, k=3): s = E @ plonger(q); return list(np.argsort(-s)[:k]), s
def rrf(listes, k=60):
    sc = Counter()
    for l in listes:
        for r, i in enumerate(l): sc[i] += 1 / (k + r + 1)
    return [i for i, _ in sc.most_common()]
q = "le robot devient lent quand il fait chaud"
lex = bm25.chercher(q, 4); den, s = dense(q, 4); hyb = rrf([lex, den])
print("BM25   :", lex, "\ndense  :", den, "\nhybride:", hyb[:4])
print("meilleur hybride →", textes[hyb[0]][:120], "…")
# Reclassement (cross-encodeur simulé) : ici, un score qui exige la présence conjointe des concepts de la question
def rerank(q, cands):
    concepts = set(tokens_sem(q)) - {"le", "il", "quand", "fait", "robot"}
    return sorted(cands, key=lambda i: -len(concepts & set(tokens_sem(textes[i]))))
print("reclassé →", rerank(q, hyb[:4]))

Pipeline standard en production : BM25 + dense → RRF → top-20 → cross-encodeur → top-5 → LLM. Le lexical garantit les termes exacts (références, noms), le dense les reformulations, le reclassement la précision finale.

01 / Construire

Génération avec citations, et le prompt qui contraint le modèle

# Le prompt d'un RAG a une structure fixe. Ici, sans LLM dans le navigateur, on montre la construction et un "générateur" extractif jouet.
def construire_prompt(question, morceaux):
    ctx = "\n\n".join(f"[{n+1}] (source : {chunks[i][0]})\n{textes[i]}" for n, i in enumerate(morceaux))
    return f"""Tu es un assistant technique. Réponds UNIQUEMENT à partir des extraits ci-dessous.
Si l'information n'y est pas, réponds exactement : "Je ne trouve pas cette information dans la documentation."
Cite chaque affirmation avec le numéro de l'extrait entre crochets, comme [2].

Extraits :
{ctx}

Question : {question}
Réponse (avec citations) :"""
p = construire_prompt("Pourquoi le robot ralentit-il quand il chauffe ?", rerank(q, hyb[:4])[:2])
print(p[:900], "…\n")
# Générateur extractif jouet : renvoie la phrase du contexte la plus proche de la question, avec sa citation
import re
def repondre_extractif(question, morceaux):
    meilleure, best, src = None, -1, None
    for n, i in enumerate(morceaux):
        for phrase in re.split(r"(?<=[.!?])\s+", textes[i]):
            sc = len(set(tokens_sem(question)) & set(tokens_sem(phrase)))
            if sc > best: best, meilleure, src = sc, phrase, n + 1
    return f"{meilleure} [{src}]" if best > 0 else "Je ne trouve pas cette information dans la documentation."
print(repondre_extractif("Pourquoi le robot ralentit-il quand il chauffe ?", rerank(q, hyb[:4])[:2]))
print(repondre_extractif("Quelle est la garantie du robot ?", hyb[:2]))

Trois règles du prompt : périmètre (uniquement les extraits), refus explicite (phrase exacte, testable), citations (vérifiables automatiquement : chaque [n] doit pointer vers un extrait qui contient l’affirmation). Sur PC, le même prompt alimente un modèle local (llama.cpp, Ollama) ou une API.

02 / Mesurer

Évaluer la recherche : rappel@k, MRR, nDCG — sur un jeu de questions annotées

import numpy as np
# Jeu d'évaluation : question → ensemble des morceaux pertinents (annotés à la main : c'est le vrai travail)
def trouver(mot): return {i for i, t in enumerate(textes) if mot.lower() in t.lower()}
jeu = [("Quel fusible utiliser ?", trouver("fusible")), ("fréquence du lidar", trouver("5,5 Hz")), ("le robot ralentit quand il chauffe", trouver("rapport cyclique")),
       ("stockage des batteries", trouver("LiPo")), ("odométrie qui dérive", trouver("dérive") | trouver("/odom")), ("rayon de braquage", trouver("braquage"))]
def rappel_k(classement, pertinents, k): return len(set(classement[:k]) & pertinents) / len(pertinents)
def mrr(classement, pertinents):
    for r, i in enumerate(classement):
        if i in pertinents: return 1 / (r + 1)
    return 0.0
def ndcg_k(classement, pertinents, k):
    dcg = sum(1 / np.log2(r + 2) for r, i in enumerate(classement[:k]) if i in pertinents)
    idcg = sum(1 / np.log2(r + 2) for r in range(min(k, len(pertinents)))); return dcg / idcg
systemes = {"BM25": lambda q: bm25.chercher(q, 10), "dense": lambda q: dense(q, 10)[0], "hybride RRF": lambda q: rrf([bm25.chercher(q, 10), dense(q, 10)[0]])[:10]}
print(f"{'système':12s} {'R@1':>6s} {'R@3':>6s} {'MRR':>6s} {'nDCG@3':>7s}")
for nom, f in systemes.items():
    res = [(rappel_k(f(q), p, 1), rappel_k(f(q), p, 3), mrr(f(q), p), ndcg_k(f(q), p, 3)) for q, p in jeu]
    m = np.mean(res, 0); print(f"{nom:12s} {m[0]:6.2f} {m[1]:6.2f} {m[2]:6.2f} {m[3]:7.2f}")
print("\nSur 6 questions, les écarts ne sont pas significatifs (L24) : un vrai jeu d'évaluation compte 100 à 1000 questions.")
print("Mais la méthode est la bonne : mesurer la RECHERCHE seule, avant de brancher un LLM (Théorème 3).")

02 / Mesurer

Évaluer la génération : fidélité, pertinence, refus — et les vérifier automatiquement

Dimension	Question posée	Comment mesurer	Automatisable ?
Fidélité (faithfulness)	Chaque affirmation est-elle soutenue par le contexte ?	Décomposer la réponse en affirmations ; pour chacune, un juge (humain ou LLM) vérifie l’implication par les extraits cités	Oui (LLM-juge, avec validation humaine sur un échantillon)
Pertinence de la réponse	Répond-elle à la question posée ?	Juge ; ou similarité entre la question et des questions régénérées à partir de la réponse (RAGAS)	Oui
Exactitude	Est-elle vraie par rapport à une référence ?	Correspondance exacte / F1 sur les tokens (QA extractive) ; juge pour le libre	Partiellement
Citations	Les [n] existent-ils et soutiennent-ils l’affirmation ?	Vérification syntaxique (regex) + implication (juge)	Oui
Refus correct	Sur une question hors corpus, le modèle refuse-t-il ?	Jeu de questions « pièges » ; taux de refus attendu	Oui (phrase exacte)
Pertinence du contexte	Quelle fraction des extraits fournis est utile ?	Juge par extrait ; précision du contexte	Oui

03 / Passer à l’échelle

Index approximatif : l’idée de HNSW et le compromis rappel/vitesse, mesuré

import numpy as np, time
rng = np.random.default_rng(0)
N, d = 20000, 32; X = rng.normal(0, 1, (N, d)); X /= np.linalg.norm(X, axis=1, keepdims=True)
Q = rng.normal(0, 1, (50, d)); Q /= np.linalg.norm(Q, axis=1, keepdims=True); k = 10
t0 = time.perf_counter(); exact = np.argsort(-(Q @ X.T), 1)[:, :k]; t_exact = time.perf_counter() - t0
# IVF (inverted file) : k-means grossier en C cellules ; chercher seulement dans les nprobe cellules les plus proches
C = 64; centres = X[rng.choice(N, C, replace=False)]
for _ in range(8):
    a = np.argmax(X @ centres.T, 1)
    for c in range(C):
        if (a == c).any(): centres[c] = X[a == c].mean(0); centres[c] /= np.linalg.norm(centres[c])
cellules = [np.where(a == c)[0] for c in range(C)]
def ivf(q, nprobe):
    cand = np.concatenate([cellules[c] for c in np.argsort(-(centres @ q))[:nprobe]])
    return cand[np.argsort(-(X[cand] @ q))[:k]]
print(f"exact : {t_exact*1000/len(Q):.2f} ms/requête")
for nprobe in (1, 2, 4, 8, 16):
    t0 = time.perf_counter(); res = [ivf(q, nprobe) for q in Q]; t = (time.perf_counter() - t0) / len(Q)
    rappel = np.mean([len(set(r) & set(e)) / k for r, e in zip(res, exact)])
    print(f"IVF nprobe={nprobe:2d} : rappel@10 = {rappel:.2f}, {t*1000:.2f} ms/requête, {nprobe/C*100:.0f} % des vecteurs visités")
print("\nHNSW (Malkov & Yashunin 2016) fait mieux : un graphe où chaque vecteur est relié à ses voisins, avec des couches")
print("« autoroutes » ; la recherche descend gloutonnement de couche en couche : ~log N distances calculées, rappel > 0,95.")

En production : FAISS (Meta), hnswlib, ou une base vectorielle (pgvector, Qdrant, Milvus). Retenez le compromis : rappel de l’index ANN × rappel du modèle de plongement = rappel total ; mesurez les deux.

04 / Diagnostiquer

Les modes d’échec d’un RAG et leur remède

Symptôme	Cause probable	Diagnostic	Remède
« Je ne trouve pas » alors que l’info existe	Rappel : découpage, vocabulaire, index	Rappel@k sur le jeu annoté ; inspecter les top-k	Hybride, reclassement, chunks plus grands ou par section, réécriture de requête (HyDE, multi-requêtes)
Réponse fausse mais confiante	Contexte non pertinent fourni, ou modèle qui ignore le contexte	Fidélité ; tester avec contexte contradictoire volontaire	Prompt plus strict, reclassement, modèle plus grand, citations obligatoires
Réponse partielle	Info répartie sur plusieurs morceaux, k trop petit	Rappel@k croît avec k ?	k plus grand, fusion parent-enfant (chercher petit, fournir grand), RAG itératif
Réponse obsolète	Index non rafraîchi ; doublons de versions	Date des sources dans les métadonnées	Ré-indexation incrémentale, filtre par date, dédoublonnage
Lent / cher	Trop de contexte, index exact	Profil : recherche vs préremplissage vs génération	ANN, cache des plongements, k plus petit après reclassement, modèle plus petit
Fuite de données	Pas de contrôle d’accès à la recherche	Tester avec un utilisateur non autorisé	Filtrer les morceaux par droits avant la génération
Injection de prompt via les documents	Un document contient des instructions	Documents pièges dans le corpus de test	Séparer clairement données et consignes, modèle robuste, filtrage

05 / Articles

Les articles à lire

Article	Contribution	À retenir
Robertson & Zaragoza, The Probabilistic Relevance Framework: BM25 and Beyond, 2009	Fondements probabilistes de BM25	Toujours une baseline redoutable ; le lexical n’est pas mort
Karpukhin et al., Dense Passage Retrieval, EMNLP 2020 — 2004.04906	Bi-encodeur BERT entraîné par contraste avec négatifs durs	Bat BM25 en QA ouverte ; l’entraînement contrastif est la clé
Lewis et al., Retrieval-Augmented Generation, NeurIPS 2020 — 2005.11401	Le terme RAG ; recherche dense + générateur entraînés ensemble	Le RAG moderne est « frozen » (sans entraînement conjoint) : plus simple, presque aussi bon
Khattab & Zaharia, ColBERT, SIGIR 2020 — 2004.12832	Interaction tardive : un vecteur par token, MaxSim	Précision du cross-encodeur à un coût proche du bi-encodeur
Malkov & Yashunin, HNSW, 2016 — 1603.09320	Graphe hiérarchique navigable pour ANN	Standard de fait ; paramètres M, efConstruction, efSearch
Johnson et al., Billion-scale similarity search with GPUs (FAISS), 2017 — 1702.08734	IVF + PQ à l’échelle du milliard	Compression des vecteurs sans perte de rappel majeure
Gao et al., HyDE, 2022 — 2212.10496	Générer une réponse hypothétique puis chercher avec son plongement	Réécriture de requête : gain fort sans entraînement
Es et al., RAGAS, 2023 — 2309.15217	Métriques automatiques : fidélité, pertinence réponse/contexte	LLM-juge à valider par des humains (L32)
Liu et al., Lost in the Middle, 2023 — 2307.03172	Les LLM utilisent mal l’information au milieu d’un long contexte	Mettre les extraits les plus pertinents au début et à la fin ; k modéré
Asai et al., Self-RAG, 2023 — 2310.11511	Le modèle décide quand chercher et critique ses réponses	Vers le RAG agentique
Gao et al., Retrieval-Augmented Generation for LLMs: A Survey, 2023 — 2312.10997	Panorama : naïf, avancé, modulaire	Carte du domaine pour choisir ses briques

TP guidé

TP — Un RAG complet sur vos documents, mesuré (6 h)

Installer. pip install sentence-transformers rank-bm25 faiss-cpu pypdf ; un LLM local via Ollama (ollama pull llama3.1:8b) ou une API.
Corpus. 20–50 documents que vous connaissez (cours, manuels, notes). Extraction texte (pypdf), découpage par sections puis par ~300 tokens avec chevauchement ; métadonnées (source, page, date).
Jeu d’évaluation. 50 questions avec, pour chacune, les morceaux pertinents (ids) et une réponse de référence ; 10 questions hors corpus. C’est l’étape la plus longue et la plus importante.
Recherche. BM25 (rank-bm25), dense (all-MiniLM-L6-v2 puis bge-m3), hybride RRF, reclassement (cross-encoder/ms-marco-MiniLM). Tableau rappel@1/3/5, MRR, nDCG pour chaque configuration. Un graphique rappel@k en fonction de k.
Génération. Prompt avec citations et refus ; 3 modèles (8B local, 70B ou API). Fidélité et pertinence par LLM-juge sur les 50 questions, validées à la main sur 15 (accord juge/humain ?). Taux de refus correct sur les 10 pièges.
Ablations. Taille des chunks (150/300/600), k (2/5/10), avec/sans reclassement, position des extraits. Un tableau : configuration → rappel, fidélité, latence, coût en tokens.
Livrable. Dépôt (ingestion, index, évaluation reproductible), rapport avec les tableaux, et une page « les 5 échecs les plus instructifs et ce que j’ai changé ».

Exercices

Exercices auto-corrigés

Exercice 1 — nDCG avec pertinences graduées

Implémentez ndcg(classement, pertinence, k) où pertinence est un dict id → gain ∈ {0, 1, 2, 3} (gain 2^rel − 1), et vérifiez les propriétés : classement idéal → 1 ; inverser deux documents de gains différents baisse le score ; un document non pertinent en tête coûte plus qu’en position 10.

Correction

def ndcg(classement, pertinence, k):
    dcg = sum((2 ** pertinence.get(d, 0) - 1) / np.log2(r + 2) for r, d in enumerate(classement[:k]))
    ideal = sorted(pertinence.values(), reverse=True)[:k]
    idcg = sum((2 ** g - 1) / np.log2(r + 2) for r, g in enumerate(ideal))
    return dcg / idcg if idcg > 0 else 0.0

Exercice 2 — Découpage qui respecte les phrases

Écrivez decouper_phrases(texte, max_mots, chevauchement_phrases) : regroupe des phrases entières (jamais coupées) jusqu’à ~max_mots, avec un chevauchement d’un nombre donné de phrases entre morceaux consécutifs. Aucune phrase ne doit être perdue.

Correction

def decouper_phrases(texte, max_mots=30, chevauchement_phrases=1):
    phrases = re.split(r"(?<=[.!?])\s+", texte.strip()); morceaux = []; i = 0
    while i < len(phrases):
        j, n = i, 0
        while j < len(phrases) and (n + len(phrases[j].split()) <= max_mots or j == i): n += len(phrases[j].split()); j += 1
        morceaux.append(" ".join(phrases[i:j]))
        if j >= len(phrases): break
        i = max(i + 1, j - chevauchement_phrases)
    return morceaux

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Fusion RRF et sa propriété

Implémentez rrf_fusion(listes, k=60) et vérifiez : invariance par transformation monotone des scores (on ne vous donne que des rangs), et qu’un document présent dans deux listes en position 3 dépasse un document présent en position 1 dans une seule.

Correction

def rrf_fusion(listes, k=60):
    from collections import Counter
    sc = Counter()
    for l in listes:
        for r, d in enumerate(l): sc[d] += 1 / (k + r + 1)
    return [d for d, _ in sc.most_common()]

Exercice 4 — Borne du Théorème 3

On mesure rappel@5 = 0,7 ; exactitude du modèle quand le contexte contient la réponse : 0,9 ; sans contexte : 0,2. Complétez exactitude_attendue et rappel_necessaire(cible) (rappel minimal pour atteindre une exactitude cible, ou None si impossible même avec rappel 1).

Correction

def exactitude_attendue(rappel, p_avec, p_sans): return rappel * p_avec + (1 - rappel) * p_sans
def rappel_necessaire(cible, p_avec, p_sans):
    if cible > p_avec: return None
    return (cible - p_sans) / (p_avec - p_sans)

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Un corpus de 10 000 pages (≈ 5 M tokens) est découpé en morceaux de 400 tokens avec chevauchement 50. Nombre de morceaux ? Taille de l’index dense (768 dims, float32) ? Temps d’une recherche exacte en NumPy (≈ 10⁹ multiplications-additions/s) ? Faut-il un index ANN ?

Correction. Morceaux ≈ (5·10⁶ − 50)/(400 − 50) ≈ 14 300. Index : 14 300 × 768 × 4 octets = 44 Mo. Recherche exacte : 14 300 × 768 ≈ 1,1·10⁷ opérations ≈ 11 ms. Un index ANN n’apporte rien ici (il coûterait du rappel pour gagner 10 ms) ; l’ANN devient nécessaire vers 10⁶ vecteurs (1 s par requête en exact). Règle : commencer exact ; passer en ANN quand la latence de recherche dépasse celle de la génération.

Exercice 2. Le RAG répond souvent « je ne trouve pas » sur des questions dont la réponse est dans une table d’un PDF. Pourquoi, et que faire ?

Correction. Causes : l’extraction texte casse les tables (cellules mélangées, en-têtes séparés des valeurs) ; le découpage sépare la ligne de son en-tête ; le plongement d’une ligne de chiffres est peu informatif ; la question en langage naturel (« consommation du moteur ») ne partage aucun mot avec la cellule (« 3 A »). Remèdes : extraction structurée des tables (pdfplumber, Camelot, ou un modèle de layout, L29) et conversion en texte explicite (« Courant maximal par moteur : 3 A ») ; un morceau par ligne avec l’en-tête et le titre de la table ; métadonnées ; recherche hybride (le lexical trouve « moteur ») ; pour les questions numériques, un outil (SQL sur la table extraite) plutôt que la génération.

Exercice 3. Deux équipes comparent leurs RAG : A affiche 78 % de « réponses correctes » selon un LLM-juge, B 71 % selon des annotateurs humains. Peut-on conclure ?

Correction. Non : les juges diffèrent (un LLM-juge peut être plus indulgent, ou biaisé vers les réponses longues et les formulations proches des siennes), les jeux de questions diffèrent, et sans intervalles de confiance ni taille d’échantillon on ne sait rien (L24). Protocole valable : même jeu de 200+ questions, mêmes extraits de référence, mêmes deux juges (humain sur un sous-ensemble pour calibrer le LLM-juge : mesurer l’accord, kappa de Cohen), rapporter fidélité, pertinence et exactitude séparément avec IC, plus le rappel@k de la recherche pour expliquer les écarts.

Vérification

Votre RAG donne 55 % de bonnes réponses. Le rappel@5 de la recherche est de 60 %. Quel est le levier prioritaire ?

Deux questions supplémentaires

1. Pourquoi combiner BM25 et dense ? Le lexical trouve les termes exacts (codes, noms), le dense les reformulations ; RRF fusionne sans normaliser les scores.

2. Qu’est-ce que la fidélité ? La proportion des affirmations de la réponse soutenues par les extraits fournis — indépendamment de leur vérité absolue.

Référence

Les mots à retenir

Mot	Définition
Chunk	Morceau de document indexé ; sa taille et ses frontières conditionnent le rappel.
BM25	Score lexical probabiliste : IDF × TF saturée × normalisation de longueur.
Bi-encodeur / cross-encodeur	Plongements séparés (indexable) / paire encodée ensemble (reclassement précis).
ANN, HNSW	Recherche approximative des plus proches voisins ; graphe navigable hiérarchique.
RRF	Fusion de classements par somme de 1/(60 + rang).
Rappel@k, MRR, nDCG	Métriques de recherche ; le rappel plafonne le RAG.
Fidélité	Réponse soutenue par le contexte ; mesurée par juge.
Injection via documents	Instructions cachées dans le corpus ; séparer données et consignes.

Suite

Vous savez alimenter un modèle. Il reste à comprendre le modèle lui-même.

Le chapitre suivant ouvre les LLM : pré-entraînement, alignement (SFT, RLHF, DPO), tokenisation, décodage, capacités et limites, coûts — et comment les faire tourner chez vous.

← L25 Sommaire L27 : LLM →