Bien démarrer avec les RAG evaluation
Ton RAG a l'air de marcher. C'est exactement pour ça qu'il va te trahir.
Sur notre premier prototype, 50 questions de test donnaient 41 bonnes réponses. La version suivante, validée « au feeling » par trois développeurs, tombait à 33. Même modèle, même base documentaire, un chunking légèrement différent. Sans banc d'essai, tu n'aurais jamais vu la régression : les réponses restaient fluides, bien écrites et fausses.
L'évaluation RAG n'est pas une case à cocher de fin de projet. C'est le seul instrument qui te dit si ton dernier commit améliore ou détruit ton système. Voici comment poser les bases sans y passer trois semaines.
Ce qui casse un RAG sans prévenir
Un RAG échoue de trois façons, et elles ne se ressemblent pas à l'usage.
- Le retrieval passe à côté : le bon passage n'est jamais envoyé au modèle. La réponse sera confiante et hors sujet, parce que le LLM comble le vide.
- Le retrieval ramène trop : quinze chunks dont trois utiles. Le modèle noie le signal et cite un paragraphe obsolète.
- Le modèle invente : les bons chunks sont là, la réponse ne les suit pas. C'est le seul cas que les utilisateurs repèrent tout seuls.
Chacun de ces cas se corrige à un endroit différent du pipeline. Si tu ne mesures qu'un score global de « qualité de réponse », tu vas passer trois semaines à retoucher ton prompt alors que ton problème est un découpage de documents à 2000 tokens.
Les trois couches à mesurer séparément
Découpe ton évaluation comme tu découpes ton architecture.
- Retrieval — le bon document est-il dans le top-k ? Métriques : recall@k, MRR, nDCG@10. Résultat binaire, pas d'interprétation.
- Génération — la réponse est-elle fidèle au contexte fourni ? Métriques : faithfulness, answer relevancy, context precision.
- Bout-en-bout — l'utilisateur obtient-il ce qu'il est venu chercher ? Métriques : exactitude sur réponses de référence, taux de « je ne sais pas » correct, coût et latence par requête.
La séparation n'est pas cosmétique. Un faithfulness à 0,95 avec un recall@5 à 0,55 te dit que ton générateur est excellent et que ta recherche est le problème. Un score global t'aurait laissé deviner lequel des deux jeter.
Écris ton jeu de test avant ton évaluateur
Le golden set est la partie que tout le monde saute. C'est aussi la seule qui ne s'automatise pas entièrement : les questions doivent venir de vrais besoins, pas du modèle.
Vise 40 à 100 entrées, réparties en quatre familles : réponse présente dans un seul document, réponse répartie sur plusieurs documents, réponse absente du corpus, question ambiguë. La dernière famille est la plus importante et la plus oubliée : un RAG qui répond toujours quelque chose est un RAG qui ment.
{"id": "q001", "question": "Combien de temps est conservé un log d'accès ?", "doc_ids": ["logs-retention"], "reponse_reference": "30 jours, sauf rétention étendue à 12 mois.", "type": "simple"}
{"id": "q002", "question": "Que se passe-t-il après trois échecs de webhook ?", "doc_ids": ["webhooks-retry", "queues-dlq"], "reponse_reference": "Le message part en file morte et une alerte est envoyée.", "type": "multi-doc"}
{"id": "q003", "question": "Quel est le tarif du plan Enterprise ?", "doc_ids": [], "reponse_reference": "Aucune information dans la base, le système doit dire qu'il ne sait pas.", "type": "hors-corpus"}Stocke ça en JSONL dans ton dépôt. Deux colonnes suffisent à détecter des régressions graves : doc_ids pour le retrieval, reponse_reference pour le jugement. Interdis-toi de recopier les questions depuis tes documents : tu testerais ta capacité à faire une recherche par mot-clé, pas ton système.
Mesurer le retrieval à la main, sans framework
Commence par le calcul le plus simple possible. Trente lignes de Python, zéro dépendance lourde, et tu sais déjà où tu perds.
def recall_at_k(retrieves, attendus, k=5):
top_k = set(retrieves[:k])
return len(top_k & set(attendus)) / len(attendus)
def reciprocal_rank(retrieves, attendus):
for rang, doc_id in enumerate(retrieves, start=1):
if doc_id in attendus:
return 1 / rang
return 0.0
recalls, rrs = [], []
for cas in charger("golden.jsonl"):
hits = retriever.search(cas["question"], k=10) # liste ordonnee de doc_ids
recalls.append(recall_at_k(hits, cas["doc_ids"]))
rrs.append(reciprocal_rank(hits, cas["doc_ids"]))
print(f"recall@5 = {sum(recalls)/len(recalls):.3f}")
print(f"MRR = {sum(rrs)/len(rrs):.3f}")Un recall@5 à 0,62 ne veut pas dire « 62 % de bonnes réponses ». Il veut dire que dans 38 % des cas, le bon passage n'est même pas dans le contexte envoyé au modèle. Aucun prompt ne rattrape ça.
Ajoute nDCG@10 seulement si tu as besoin de l'ordre — utile quand plusieurs documents comptent, inutile quand une seule source suffit. Les définitions de référence sont dans l'article BEIR (arXiv:2104.08663), qui reste la référence pour comparer des retriever sur des corpus hors domaine.
Teste aussi le chunking seul, avant tout reranker : sur beaucoup de corpus techniques, passer de 1000 à 400 tokens avec recouvrement fait plus gagner que n'importe quel modèle de reranking. Fais-le une fois, mesure, garde ce qui gagne chez toi.
Mesurer la génération avec RAGAS
Pour la couche fidélité, les métriques de RAGAS (arXiv:2309.15217) sont le point de départ le plus rapide : elles décomposent la réponse en affirmations et vérifient chaque affirmation contre le contexte récupéré.
from datasets import Dataset
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision, context_recall
data = {
"question": [cas["question"] for cas in cas_rejoues],
"answer": [cas["reponse_produite"] for cas in cas_rejoues],
"contexts": [cas["contextes"] for cas in cas_rejoues],
"ground_truth": [cas["reponse_reference"] for cas in cas_rejoues],
}
resultat = evaluate(Dataset.from_dict(data), metrics=[
faithfulness, answer_relevancy, context_precision, context_recall,
])
print(resultat.to_pandas()[["faithfulness", "context_recall"]].mean())Deux pièges concrets. Le premier : l'API RAGAS a bougé entre les versions 0.1 et 0.2, les noms d'arguments ne sont pas stables. Épingle la version exacte dans ton requirements.txt, sinon ton score changera sans que ton code change. Le second : chaque métrique coûte un appel LLM par question. Un golden set de 100 questions et quatre métriques, c'est 400 appels à chaque exécution complète.
Si ton corpus est gros et tes questions spécialisées, ARES (arXiv:2311.09476) et RAGChecker (arXiv:2408.08067) offrent des découpages plus fins des erreurs de retrieval et de génération. Garde-les pour l'audit trimestriel, pas pour la CI.
Le juge LLM a des biais mesurables
Un juge automatique est pratique, mais il n'est pas neutre, et ça se mesure. Le papier MT-Bench (arXiv:2306.05685) montre qu'un juge GPT-4 tombe d'accord avec les humains environ 80 % du temps — soit à peu près le niveau d'accord entre deux humains. C'est bon, ce n'est pas parfait : un score de faithfulness à 0,90 contient donc un dixième de bruit.
Trois biais documentés à connaître avant de faire confiance à un chiffre :
- Biais de position : le juge préfère souvent la première réponse présentée. Inverse l'ordre et le verdict change (arXiv:2305.17926).
- Biais d'auto-préférence : un modèle juge préfère ses propres sorties (arXiv:2404.13076). Si tu génères et juges avec le même modèle, ton score est optimiste.
- Biais de verbosité : une réponse longue est jugée plus complète à contenu égal.
La règle que j'applique : le juge triage, l'humain tranche sur un échantillon. Garde 20 à 30 % de ton golden set annoté à la main, vérifie que le juge est d'accord avec ces étiquettes, et note la version du modèle juge à côté de chaque score. Un score sans version de juge n'est pas comparable d'un mois sur l'autre.
Brancher l'évaluation dans la CI
Une évaluation que personne ne lance ne sert à rien. Deux exécutions suffisent : un sous-ensemble court sur chaque pull request, le golden set complet sur la branche principale.
# tests/test_rag_eval.py
import pytest
from deepeval import assert_test
from deepeval.metrics import FaithfulnessMetric
from deepeval.test_case import LLMTestCase
SEUIL = 0.80
@pytest.mark.parametrize("cas", charger("tests/golden/rag.jsonl")[:20])
def test_faithfulness(cas):
reponse, contextes = interroger_le_rag(cas["question"])
assert_test(
LLMTestCase(
input=cas["question"],
actual_output=reponse,
retrieval_context=contextes,
),
[FaithfulnessMetric(threshold=SEUIL)],
)Trois règles de seuil. Fixe le seuil à partir de la mesure actuelle moins une marge, jamais à partir d'un objectif théorique. Bloque la fusion en cas de baisse de recall@5, alerte sans bloquer en cas de baisse de faithfulness. Enregistre chaque exécution (question, contexte, réponse, scores) dans un endroit interrogeable — MLflow ou même une table SQLite suffit — sinon tu ne pourras pas expliquer pourquoi le score a chuté en mars.
Le coût réel d'un run de contrôle sur 20 questions avec un juge économique se compte en centimes, une fraction du prix d'une régression invisible en production. Sur notre dépôt, la suite courte prend 40 secondes et un reranker mal configuré a été détecté en une exécution — la baisse de recall@5 était de 0,18, invisible à l'œil sur dix réponses.
Ce qui casse dans les six premières semaines
Les mêmes erreurs reviennent dans le même ordre.
- Aucune question « réponse absente » : le système apprend à toujours répondre, et personne ne le remarque avant l'incident client.
- Le golden set dérive : deux personnes l'enrichissent de questions tirées du corpus, et le recall devient artificiellement bon.
- Un seul chiffre agrégé : le tableau de bord affiche « qualité 82 % » et personne ne sait quoi corriger.
- Le juge change de version sans être noté, et une « amélioration » de 5 points est en réalité un changement de modèle.
- L'évaluation tourne à la main, une fois, avant la mise en production. Donc jamais après.
Un banc d'essai RAG tient en une journée de travail : un JSONL, trente lignes de métriques de retrieval, un appel RAGAS, une suite de tests. Ce que tu y gagnes, c'est le droit de modifier ton chunking, ton embedding ou ton prompt sans jouer ta production à pile ou face. Si tu optimises ton serving en parallèle, la même logique s'applique côté inférence — voir notre retour sur déployer vLLM en production. Et si tu veux un modèle de référence gratuit pour le juge, la liste des outils gratuits de machine learning fait le tour des options utilisables en CI.