De zoekkwaliteit evalueren
Op deze pagina
Doelstellingen
- De standaardmetrieken voor zoekevaluatie begrijpen
- Een evaluatiedataset opbouwen
- De kwaliteit van uw engine meten en verbeteren
Waarom evalueren?
Eerdere lessen introduceerden een reeks keuzes: embedding-model, aantal dimensies, chunk-grootte en hybride weging. Elke keuze kan uw systeem verbeteren of verslechteren. Subjectieve indrukken op basis van het handmatig testen van drie query’s zijn niet voldoende om een beslissing te nemen—zeker omdat een wijziging vaak de ene categorie query’s verbetert terwijl een andere verslechtert. Zonder metrieken vliegt u blind.
Belangrijkste metrieken
Recall@k beantwoordt deze vraag: van de relevante documenten, hoeveel verschijnen er in de top k resultaten? Dit is de gouden standaardmetriek voor RAG, omdat een document dat ontbreekt in de context nooit door het generatiemodel kan worden geciteerd, hoe goed het ook is.
def recall_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proportion of relevant documents found in the top-k."""
top_k = set(resultats[:k])
trouves = pertinents & top_k
return len(trouves) / len(pertinents) if pertinents else 0.0
Precision@k kijkt naar het omgekeerde: van de k teruggegeven resultaten, hoeveel zijn daadwerkelijk relevant? Dit is vooral belangrijk wanneer de context die naar de LLM wordt verzonden beperkt is, omdat elk off-topic document ruimte inneemt en de aandacht van het model verdunt.
def precision_at_k(pertinents: set[str], resultats: list[str], k: int) -> float:
"""Proportion of relevant results in the 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) meet de rang van het eerste relevante resultaat. Een document op de eerste plaats scoort 1, op de tweede plaats 0,5 en op de vijfde plaats 0,2. Geef prioriteit aan deze metriek voor zoekbalken die voor mensen zijn bedoeld, omdat ze zelden verder kijken dan de eerste drie regels.
def mrr(pertinents: set[str], resultats: list[str]) -> float:
"""Reciprocal rank of the first relevant result."""
for i, r in enumerate(resultats):
if r in pertinents:
return 1.0 / (i + 1)
return 0.0
NDCG@k (Normalized Discounted Cumulative Gain) gaat verder door binaire relevantie los te laten: het accepteert gradaties van relevantie, waardoor u onderscheid kunt maken tussen een document dat de vraag exact beantwoordt en een document dat er slechts kort op ingaat. De logaritme in de noemer past een progressieve korting toe op basis van de rang, en normalisatie ten opzichte van de ideale rangschikking schaalt alles tussen 0 en 1.
import numpy as np
def ndcg_at_k(relevances: list[float], k: int) -> float:
"""NDCG with graded relevance scores."""
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
Een evaluatiedataset maken
Geen van deze formules is nuttig zonder grondwaarheid. Een evaluatiedataset koppelt elke query aan de lijst documenten die moeten verschijnen, en optioneel aan die welke dat zeker niet moeten—deze laatste zijn nuttig voor het monitoren van bekende false positives.
import json
# Dataset structure
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"]
},
]
# Save
with open("eval_dataset.json", "w") as f:
json.dump(dataset_eval, f, ensure_ascii=False, indent=2)
Dertig goed gekozen paren die de verschillende soorten vragen dekken die uw engine daadwerkelijk ontvangt, zijn meer waard dan driehonderd massaal geproduceerde. Geef prioriteit aan het halen van gegevens uit uw zoeklogs: dit zijn de daadwerkelijke formuleringen van uw gebruikers, niet die welke u zich voorstelt.
Testquery’s genereren met een LLM
Bij een groot corpus wordt handmatig schrijven onpraktisch. We draaien het probleem daarom om: in plaats van te zoeken naar documenten die een vraag beantwoorden, vragen we een model welke vragen een bepaald document kan behandelen. Het document is per constructie relevant voor deze vragen, en u heeft binnen enkele minuten paren.
from openai import OpenAI
client = OpenAI()
def generer_requetes_test(document: str, n: int = 3) -> list[str]:
"""Generate n queries that this document should answer."""
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")
Deze methode heeft een blind vlek die u moet kennen: gegenereerde vragen gebruiken vaak exact hetzelfde vocabulaire als het document, waardoor ze gemakkelijker zijn dan echte gebruikersquery’s en uw scores kunstmatig verhogen. Gebruik ze om twee configuraties met elkaar te vergelijken, nooit om een absoluut kwaliteitsniveau vast te stellen.
Volledige evaluatiepijplijn
De evaluator voert elke query uit de dataset uit op de engine, berekent alle metrieken voor verschillende waarden van k en middelt vervolgens de hele set.
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:
"""Evaluate the engine on a complete dataset."""
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:
# Run search
res = self.moteur.rechercher(item["requête"], k=max(k_values))
ids_resultats = [r["id"] for r in res]
pertinents = set(item["pertinents"])
# Calculate metrics
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)
)
# Average
return {
metrique: round(np.mean(scores), 4)
for metrique, scores in resultats.items()
}
# Usage
evaluateur = EvaluateurRecherche(moteur)
metriques = evaluateur.evaluer(dataset_eval)
print("Résultats d'évaluation :")
for metrique, score in metriques.items():
print(f" {metrique}: {score}")
Het volgen van meerdere waarden van k is op zichzelf al instructief: een hoge recall@10 gecombineerd met een slechte recall@1 signaleert dat de juiste documenten wel worden gevonden, maar slecht gerangschikt—een herordeningsprobleem, geen indexeringsprobleem.
Twee configuraties vergelijken
De volgende functie zet twee engines tegen elkaar op dezelfde dataset en toont het metriekverschil per metriek. Herhaal deze stap voor elke productie-implementatie, zelfs voor een wijziging die triviaal lijkt.
def comparer_configs(moteur_a, moteur_b, dataset, noms=("A", "B")):
"""Compare two search engines."""
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}")
Lees delta’s voorzichtig bij een kleine dataset: een verschil van 0,02 over dertig query’s is waarschijnlijk ruis, terwijl een daling van 0,10 in recall@5 een duidelijk signaal is om niet te implementeren.
Belangrijkste punten
- Recall@k, Precision@k, MRR en NDCG zijn de standaardmetrieken
- Maak een evaluatiedataset met paren van (query, relevante documenten)
- Automatiseer het genereren van query’s met een LLM
- Vergelijk configuraties systematisch voordat u implementeert