Vyhodnocení kvality vyhledávání
Na této stránce
Cíle
- Porozumět standardním metrikám pro hodnocení vyhledávání
- Vytvořit evaluační dataset
- Změřit a zlepšit kvalitu tvého engine
Proč vyhodnocovat?
Předchozí lekce představily řadu voleb: model pro embeddingy, počet dimenzí, velikost chunku a váhy hybridního vyhledávání. Každá volba může tvůj systém zlepšit nebo zhoršit. Subjektivní dojmy z ručního otestování tří dotazů nestačí k rozhodnutí – zejména proto, že změna často zlepší jednu kategorii dotazů, zatímco jinou zhorší. Bez metrik létáš naslepo.
Klíčové metriky
Recall@k odpovídá na otázku: kolik relevantních dokumentů se objeví v top $k$ výsledcích? Toto je zlatý standard pro RAG, protože dokument chybějící v kontextu nemůže generační model nikdy citovat, ať je sebelepší.
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 se dívá na opak: kolik z vrácených $k$ výsledků je skutečně relevantních? To je nejdůležitější, když je kontext posílaný do LLM omezený, protože každý dokument mimo téma zabírá místo a rozptyluje pozornost modelu.
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ěří pořadí prvního relevantního výsledku. Dokument na prvním místě získá 1, na druhém 0,5 a na pátém 0,2. Tuto metriku upřednostni pro vyhledávací pole určená lidem, kteří zřídka hledají dál než za prvními třemi řádky.
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) jde ještě dál tím, že opouští binární relevanci: přijímá stupně relevance, což ti umožňuje rozlišit mezi dokumentem, který přesně odpovídá na otázku, a tím, který se jí jen dotýká. Logaritmus ve jmenovateli aplikuje progresivní diskontování podle pořadí a normalizace vůči ideálnímu řazení škáluje vše mezi 0 a 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
Vytvoření evaluačního datasetu
Žádný z těchto vzorců není užitečný bez ground truth. Evaluační dataset přiřazuje každému dotazu seznam dokumentů, které by se měly objevit, a volitelně i ty, které by se rozhodně objevit neměly – ty druhé jsou užitečné pro monitorování známých falešných pozitiv.
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)
Třicet dobře vybraných párů pokrývajících různé typy otázek, které tvůj engine skutečně dostává, má větší hodnotu než tři sta masově vyrobených. Upřednostni čerpání z tvých vyhledávacích logů: jsou to skutečná formulace tvých uživatelů, ne ta, která si představuješ.
Generování testovacích dotazů pomocí LLM
U velkého korpusu se ruční psaní stává nepraktickým. Proto problém otočíme: místo hledání dokumentů, které odpovídají na otázku, se zeptáme modelu, na jaké otázky může daný dokument odpovědět. Dokument je díky konstrukci pro tyto otázky relevantní a páry získáš během minut.
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")
Tato metoda má slepé místo, které musíš znát: generované otázky často znovu používají přesnou slovní zásobu dokumentu, což je činí snazšími než skutečné uživatelské dotazy a uměle nafukuje tvá skóre. Používej je k porovnání dvou konfigurací navzájem, nikdy k prohlášení absolutní úrovně kvality.
Kompletní evaluační pipeline
Evaluátor spustí každý dotaz z datasetu na enginu, vypočítá všechny metriky pro několik hodnot $k$ a následně zprůměruje celou sadu.
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}")
Sledování více hodnot $k$ je samo o sobě poučné: vysoký recall@10 v kombinaci se špatným recall@1 signalizuje, že správné dokumenty jsou nacházeny, ale špatně řazeny – jde o problém s rerankingem, ne s indexováním.
Porovnání dvou konfigurací
Následující funkce postaví proti sobě dva enginy na stejném datasetu a zobrazí rozdíl v metrikách pro každou metriku. Tento krok opakuj před každým nasazením do produkce, i když se změna zdá triviální.
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}")
Čti delty opatrně u malého datasetu: rozdíl 0,02 u třiceti dotazů je pravděpodobně šum, zatímco pokles recall@5 o 0,10 je jasný signál k nenasazování.
Klíčové poznatky
- Recall@k, Precision@k, MRR a NDCG jsou standardní metriky
- Vytvoř evaluační dataset s páry (dotaz, relevantní dokumenty)
- Automatizuj generování dotazů pomocí LLM
- Systematicky porovnávej konfigurace před nasazením