Évaluer la qualité de la recherche
Pe această pagină
Objectifs
- Comprendre les métriques standard d’évaluation de la recherche
- Construire un jeu de données d’évaluation
- Mesurer et améliorer la qualité de votre moteur
Pourquoi évaluer ?
Les leçons précédentes ont présenté une série de choix : modèle d’embedding, nombre de dimensions, taille des chunks et pondération hybride. Chaque choix peut améliorer ou dégrader votre système. Les impressions subjectives issues de tests manuels sur trois requêtes ne suffisent pas à décider, d’autant plus qu’une modification améliore souvent une catégorie de requêtes tout en dégradant une autre. Sans métriques, vous naviguez à l’aveugle.
Métriques clés
Recall@k répond à cette question : parmi les documents pertinents, combien apparaissent dans les k premiers résultats ? C’est la métrique de référence pour le RAG, car un document absent du contexte ne pourra jamais être cité par le modèle de génération, aussi performant soit-il.
def recall_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proportion de documents pertinents trouvés dans le top-k."""
top_k = set(resultats[:k])
trouves = pertinents & top_k
return len(trouves) / len(pertinents) if pertinents else 0.0
Precision@k examine l’inverse : parmi les k résultats retournés, combien sont réellement pertinents ? Cela importe surtout lorsque le contexte envoyé au LLM est limité, car chaque document hors sujet occupe de l’espace et dilue l’attention du modèle.
def precision_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proportion de résultats pertinents dans le top-k."""
top_k = resultats[:k]
trouves = sum(1 for r in top_k if r in pertinents)
return trouves / k if k > 0 else 0.0
MRR (Mean Reciprocal Rank) mesure le rang du premier résultat pertinent. Un document en première position obtient un score de 1, en deuxième position 0,5, et en cinquième position 0,2. Privilégiez cette métrique pour les barres de recherche destinées aux humains, qui regardent rarement au-delà des trois premières lignes.
def mrr(pertinents: set[str], resultats: list[str]) -> float:
"""Rang réciproque du premier résultat pertinent."""
for i, r in enumerate(resultats):
if r in pertinents:
return 1.0 / (i + 1)
return 0.0
NDCG@k (Normalized Discounted Cumulative Gain) va plus loin en abandonnant la pertinence binaire : il accepte des degrés de pertinence, vous permettant de distinguer un document qui répond exactement à la question d’un document qui ne fait que l’effleurer. Le logarithme au dénominateur applique une décote progressive selon le rang, et la normalisation par rapport au classement idéal ramène tout entre 0 et 1.
import numpy as np
def ndcg_at_k(relevances: list[float], k: int) -> float:
"""NDCG avec des scores de pertinence gradués."""
dcg = sum(
rel / np.log2(i + 2) for i, rel in enumerate(relevances[:k])
)
ideal = sorted(relevances, reverse=True)[:k]
idcg = sum(
rel / np.log2(i + 2) for i, rel in enumerate(ideal)
)
return dcg / idcg if idcg > 0 else 0.0
Créer un jeu de données d’évaluation
Aucune de ces formules n’est utile sans vérité terrain. Un jeu de données d’évaluation associe chaque requête à la liste des documents qui devraient apparaître, et éventuellement à ceux qui ne devraient absolument pas apparaître ; ces derniers sont utiles pour surveiller les faux positifs connus.
import json
# Structure du jeu de données
dataset_eval = [
{
"requête": "comment installer Python sur Windows",
"pertinents": ["doc_install_python", "doc_setup_env"],
"non_pertinents": ["doc_cuisine"]
},
{
"requête": "configurer nginx comme reverse proxy",
"pertinents": ["doc_nginx_proxy", "doc_nginx_config"],
"non_pertinents": ["doc_python_web"]
},
]
# Sauvegarde
with open("eval_dataset.json", "w") as f:
json.dump(dataset_eval, f, ensure_ascii=False, indent=2)
Trente paires bien choisies couvrant les différents types de questions que votre moteur reçoit réellement valent mieux que trois cents paires produites en masse. Privilégiez l’extraction depuis vos journaux de recherche : ce sont les formulations réelles de vos utilisateurs, pas celles que vous imaginez.
Générer des requêtes de test avec un LLM
Sur un grand corpus, la rédaction manuelle devient impraticable. Nous inversons donc le problème : au lieu de chercher des documents qui répondent à une question, nous demandons à un modèle quelles questions un document donné peut traiter. Le document est par construction pertinent pour ces questions, et vous obtenez des paires en quelques minutes.
from openai import OpenAI
client = OpenAI()
def generer_requetes_test(document: str, n: int = 3) -> list[str]:
"""Génère n questions auxquelles ce document devrait répondre."""
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Voici un document :\n\n{document}\n\n"
f"Génère {n} questions auxquelles ce document répond. "
f"Retourne uniquement les questions, une par ligne."
)
}]
)
return response.choices[0].message.content.strip().split("\n")
Cette méthode présente un angle mort que vous devez connaître : les questions générées réutilisent souvent le vocabulaire exact du document, ce qui les rend plus faciles que les requêtes réelles des utilisateurs et gonfle artificiellement vos scores. Utilisez-les pour comparer deux configurations entre elles, jamais pour déclarer un niveau de qualité absolu.
Pipeline d’évaluation complet
L’évaluateur exécute chaque requête du jeu de données sur le moteur, calcule toutes les métriques pour plusieurs valeurs de k, puis fait la moyenne sur l’ensemble.
class EvaluateurRecherche:
def __init__(self, moteur_recherche):
self.moteur = moteur_recherche
def evaluer(
self, dataset: list[dict], k_values: list[int] = [1, 3, 5, 10]
) -> dict:
"""Évalue le moteur sur un jeu de données complet."""
resultats = {f"recall@{k}": [] for k in k_values}
resultats.update({f"precision@{k}": [] for k in k_values})
resultats["mrr"] = []
for item in dataset:
# Exécution de la recherche
res = self.moteur.rechercher(item["requête"], k=max(k_values))
ids_resultats = [r["id"] for r in res]
pertinents = set(item["pertinents"])
# Calcul des métriques
resultats["mrr"].append(mrr(pertinents, ids_resultats))
for k in k_values:
resultats[f"recall@{k}"].append(
recall_at_k(pertinents, ids_resultats, k)
)
resultats[f"precision@{k}"].append(
precision_at_k(pertinents, ids_resultats, k)
)
# Moyenne
return {
metrique: round(np.mean(scores), 4)
for metrique, scores in resultats.items()
}
# Utilisation
evaluateur = EvaluateurRecherche(moteur)
metriques = evaluateur.evaluer(dataset_eval)
print("Résultats d'évaluation :")
for metrique, score in metriques.items():
print(f" {metrique}: {score}")
Le suivi de plusieurs valeurs de k est instructif en soi : un recall@10 élevé couplé à un mauvais recall@1 signale que les bons documents sont trouvés mais mal classés ; il s’agit d’un problème de reranking, pas d’indexation.
Comparer deux configurations
La fonction suivante oppose deux moteurs sur le même jeu de données et affiche l’écart de métrique par indicateur. Répétez cette étape avant chaque déploiement en production, même pour une modification qui semble triviale.
def comparer_configs(moteur_a, moteur_b, dataset, noms=("A", "B")):
"""Compare deux moteurs de recherche."""
eval_a = EvaluateurRecherche(moteur_a).evaluer(dataset)
eval_b = EvaluateurRecherche(moteur_b).evaluer(dataset)
print(f"{Métrique:<20} {noms[0]:<10} {noms[1]:<10} {Delta:<10}")
print("-" * 50)
for metrique in eval_a:
delta = eval_b[metrique] - eval_a[metrique]
signe = "+" if delta > 0 else ""
print(f"{metrique:<20} {eval_a[metrique]:<10.4f} "
f"{eval_b[metrique]:<10.4f} {signe}{delta:<10.4f}")
Lisez les deltas avec prudence sur un petit jeu de données : un écart de 0,02 sur trente requêtes est probablement du bruit, tandis qu’une chute de 0,10 du recall@5 est un signal clair pour ne pas déployer.
Puncte cheie
- Recall@k, Precision@k, MRR et NDCG sont les métriques standard
- Créez un jeu de données d’évaluation avec des paires (requête, documents pertinents)
- Automatisez la génération de requêtes avec un LLM
- Comparez systématiquement les configurations avant de déployer