Utvärdera sökkvalitet
På denna sida
Mål
- Förstå standardmått för sökutvärdering
- Bygga en utvärderingsdatamängd
- Mäta och förbättra din sökmotors kvalitet
Varför utvärdera?
Tidigare lektioner har presenterat en rad val: inbäddningsmodell, antal dimensioner, chunk-storlek och hybridviktning. Varje val kan förbättra eller försämra ditt system. Subjektiva intryck från manuell testning av tre frågor räcker inte för att avgöra detta – särskilt eftersom en ändring ofta förbättrar en kategori frågor samtidigt som den försämrar en annan. Utan mätvärden flyger du blindt.
Viktiga mått
Recall@k svarar på frågan: bland de relevanta dokumenten, hur många dyker upp bland de k första resultaten? Detta är guldstandarden för RAG, eftersom ett dokument som saknas i kontexten aldrig kan citeras av generationsmodellen, oavsett hur bra den är.
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 tittar på motsatsen: bland de k returnerade resultaten, hur många är faktiskt relevanta? Detta är viktigast när kontexten som skickas till LLM:n är begränsad, eftersom varje irrelevant dokument tar upp plats och utspäder modellens uppmärksamhet.
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) mäter rangordningen för det första relevanta resultatet. Ett dokument på första plats ger poängen 1, på andra plats 0,5 och på femte plats 0,2. Prioritera detta mått för sökfält avsedda för människor, som sällan tittar längre än de tre första raderna.
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) går ett steg längre genom att överge binär relevans: det accepterar grader av relevans, vilket låter dig skilja mellan ett dokument som svarar exakt på frågan och ett som bara berör ämnet. Logaritmen i nämnaren applicerar en progressiv rabatt baserad på rangordning, och normalisering mot den ideala rangordningen skalas allt mellan 0 och 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
Skapa en utvärderingsdatamängd
Ingen av dessa formler är användbar utan en sanningsgrund (ground truth). En utvärderingsdatamängd kopplar varje fråga till listan över dokument som borde dyka upp, och eventuellt de som definitivt inte borde göra det – de senare är användbara för att övervaka kända falska positiva träffar.
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)
Trettio välvalda par som täcker de olika typer av frågor din motor faktiskt receives är mer värda än trehundra massproducerade. Prioritera att hämta data från dina sökloggar: detta är dina användares faktiska formuleringar, inte de du inbillar dig att de använder.
Generera testfrågor med en LLM
På en stor korpus blir manuellt skrivande opraktiskt. Därför vänder vi på problemet: istället för att leta efter dokument som svarar på en fråga, ber vi en modell vilka frågor ett givet dokument kan besvara. Dokumentet är per konstruktion relevant för dessa frågor, och du får par på några minuter.
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")
Denna metod har en blind fläck du behöver känna till: genererade frågor återanvänder ofta dokumentets exakta ordval, vilket gör dem enklare än verkliga användarfrågor och artificiellt blåser upp dina poäng. Använd dem för att jämföra två konfigurationer med varandra, aldrig för att deklarera en absolut kvalitetsnivå.
Komplett utvärderingspipeline
Utvärderaren kör varje fråga från datamängden mot motorn, beräknar alla mått för flera värden på k och beräknar sedan medelvärdet för hela mängden.
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}")
Att spåra flera värden på k är i sig instruktivt: ett högt recall@10 parat med ett dåligt recall@1 signalerar att rätt dokument hittas men rankas dåligt – ett omrankningsproblem, inte ett indexeringsproblem.
Jämför två konfigurationer
Följande funktion ställer två motorer mot samma datamängd och visar skillnaden i mått per metrik. Upprepa detta steg före varje produktionssättning, även för en ändring som verkar trivial.
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}")
Läs deltapoäng försiktigt på en liten datamängd: en skillnad på 0,02 över trettio frågor är sannolikt brus, medan ett fall på 0,10 i recall@5 är en tydlig signal om att inte sätta i produktion.
Viktiga punkter
- Recall@k, Precision@k, MRR och NDCG är standardmåtten
- Skapa en utvärderingsdatamängd med par av (fråga, relevanta dokument)
- Automatisera frågegenerering med en LLM
- Jämför systematiskt konfigurationer innan driftsättning