Vyhodnotenie kvality vyhľadávania
Na tejto strane
Ciele
- Porozumieť štandardným metrikám hodnotenia vyhľadávania
- Vytvoriť hodnotiaci dataset
- Zmerať a zlepšiť kvalitu tvojho engine
Prečo hodnotiť?
Predchádzajúce lekcie predstavili sériu rozhodnutí: model vkladania (embedding), počet dimenzií, veľkosť chunku a hybridné váženie. Každá voľba môže tvoj systém zlepšiť alebo zhoršiť. Subjektívne dojmy z manuálneho testovania troch dopytov nestačia na rozhodovanie – najmä preto, že zmena často zlepší jednu kategóriu dopytov, zatiaľ čo inú zhorší. Bez metrík lietaš naslepo.
Kľúčové metriky
Recall@k odpovedá na otázku: koľko relevantných dokumentov sa objaví v top k výsledkoch spomedzi všetkých relevantných? Toto je zlatý štandard pre RAG, pretože dokument chýbajúci v kontexte nemôže generačný model nikdy citovať, nech je akokoľvek dobrý.
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 sa pozerá na opačnú stranu: koľko z vrátených k výsledkov je skutočne relevantných? Toto je najdôležitejšie, keď je kontext odosielaný do LLM obmedzený, pretože každý dokument mimo témy zaberá miesto a rozptyľuje pozornosť 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) meria poradie prvého relevantného výsledku. Dokument na prvom mieste získava 1, na druhom 0,5 a na piatom 0,2. Túto metriku uprednostni pre vyhľadávacie riadky určené ľuďom, ktorí zriedka pozerajú ďalej ako na prvé tri riadky.
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) ide ďalej tým, že opúšťa binárnu relevanciu: akceptuje stupne relevancie, čo ti umožňuje rozlíšiť medzi dokumentom, ktorý presne odpovedá na otázku, a tým, ktorý sa jej len dotýka. Logaritmus v menovateli aplikuje progresívne znehodnotenie podľa poradia a normalizácia voči ideálnemu zoradeniu škáluje všetko medzi 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
Vytvorenie hodnotiaceho datasetu
Žiadny z týchto vzorcov nie je užitočný bez ground truth. Hodnotiaci dataset priraďuje ku každému dopytu zoznam dokumentov, ktoré by sa mali objaviť, a voliteľne aj tie, ktoré by sa určite nemali – tie druhé sú užitočné na monitorovanie známych falošne pozitívnych výsledkov.
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)
Tridsať dobre vybraných párov pokrývajúcich rôzne typy otázok, ktoré tvoj engine skutočne dostáva, má väčšiu hodnotu ako tristo masovo vyrobených. Uprednostni čerpanie z tvojich logov vyhľadávania: sú to skutočné formulácie tvojich používateľov, nie tie, ktoré si predstavuješ.
Generovanie testovacích dopytov pomocou LLM
Pri veľkom korpuse sa manuálne písanie stáva nepraktickým. Preto problém otočíme: namiesto hľadania dokumentov, ktoré odpovedajú na otázku, sa opýtame modelu, na aké otázky môže daný dokument odpovedať. Dokument je konštrukčne relevantný pre tieto otázky a páry získaš za minúty.
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")
Táto metóda má slepé miesto, ktoré musíš poznať: generované otázky často používajú presnú slovnú zásobu dokumentu, čo ich robí jednoduchšími než skutočné dopyty používateľov a umelo nafukuje tvoje skóre. Použi ich na porovnanie dvoch konfigurácií navzájom, nikdy nie na vyhlásenie absolútnej úrovne kvality.
Kompletný pipeline hodnotenia
Hodnotiteľ spustí každý dopyt z datasetu na engine, vypočíta všetky metriky pre niekoľko hodnôt k a následne spriemeruje celý súbor.
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}")
Sledovanie viacerých hodnôt k je samo o sebe poučné: vysoký recall@10 v kombinácii so slabým recall@1 signalizuje, že správne dokumenty sa nachádzajú, ale sú zle zoradené – ide o problém preradenia (reranking), nie indexovania.
Porovnanie dvoch konfigurácií
Nasledujúca funkcia postaví proti sebe dva enginy na rovnakom datasete a zobrazí rozdiel metrík pre každú metriku. Tento krok opakuj pred každým nasadením do produkcie, aj pri zmene, ktorá sa zdá byť triviálna.
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}")
Čítaj delty opatrne pri malom datasete: rozdiel 0,02 pri tridsiatich dopytoch je pravdepodobne šum, zatiaľ čo pokles recall@5 o 0,10 je jasný signál, aby si nasadenie nevykonal.
Kľúčové poznatky
- Recall@k, Precision@k, MRR a NDCG sú štandardné metriky
- Vytvor hodnotiaci dataset s pármi (dopyt, relevantné dokumenty)
- Automatizuj generovanie dopytov pomocou LLM
- Systematicky porovnávaj konfigurácie pred nasadením