Oceni kakovost iskanja
Na tej strani
Cilji
- Razumevanje standardnih metrik za ocenjevanje iskanja
- Izgradnja evalvacijskega nabora podatkov
- Merjenje in izboljšanje kakovosti tvojega iskalnega pogona
Zakaj ocenjevati?
Prejšnje lekcije so predstavile niz izbir: model vgradnje, število dimenzij, velikost razdelkov in hibridno uteževanje. Vsaka izbira lahko tvoj sistem izboljša ali poslabša. Subjektivni vtisi ob ročnem testiranju treh poizvedb niso dovolj za odločitev – še posebej zato, ker sprememba pogosto izboljša eno kategorijo poizvedb, hkrati pa poslabša drugo. Brez metrik letiš na slepo.
Ključne metrike
Recall@k odgovarja na vprašanje: koliko med ustreznimi dokumenti se pojavi med prvimi k rezultati? To je zlati standard za RAG, saj dokumenta, ki manjka v kontekstu, generativni model nikoli ne more navesti, ne glede na to, kako dober je.
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 gleda obratno: koliko med vrnjenimi k rezultati je dejansko ustreznih? To je najpomembnejše, ko je kontekst, poslan LLM-ju, omejen, saj vsak dokument izven teme zavzame prostor in razredči pozornost modela.
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) meri rang prvega ustreznega rezultata. Dokument na prvem mestu dobi oceno 1, na drugem 0,5, na petem pa 0,2. To metriko daj prednost iskalnim vnosnikom, namenjenim ljudem, ki redko pogledajo dlje od prvih treh vrstic.
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) gre še dlje z opustitvijo binarne ustreznosti: sprejema stopnje ustreznosti, kar ti omogoča razlikovanje med dokumentom, ki točno odgovori na vprašanje, in tistim, ki se ga le dotakne. Logaritem v imenovalcu uporabi progresivno diskontiranje glede na rang, normalizacija glede na idealni rang pa vse umeri med 0 in 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
Ustvari evalvacijski nabor podatkov
Nobena od teh formul ni uporabna brez osnovne resnice (ground truth). Evalvacijski nabor podatkov poveže vsako poizvedbo s seznamom dokumentov, ki bi se morali pojaviti, in po želji tistih, ki se zagotovo ne bi – slednji so koristni za spremljanje znanih lažno pozitivnih rezultatov.
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)
Trideset dobro izbranih parov, ki pokrivajo različne vrste vprašanj, ki jih tvoj pogon dejansko prejme, je vrednih več kot tristo množično izdelanih. Prednost daj zajemanju iz svojih dnevnikov iskanja: to so dejanske formulacije tvojih uporabnikov, ne tiste, ki si jih ti zamišljaš.
Generiraj testne poizvedbe z LLM
Pri velikem korpusu ročno pisanje postane neizvedljivo. Zato obrnemo problem: namesto da iščemo dokumente, ki odgovarjajo na vprašanje, model vprašamo, na katera vprašanja lahko odgovori dani dokument. Dokument je po konstrukciji ustrezen za ta vprašanja, pare pa dobiš v nekaj minutah.
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")
Ta metoda ima slepo liso, ki jo moraš poznati: generirana vprašanja pogosto ponovijo točen besednjak dokumenta, zaradi česar so lažja od dejanskih uporabniških poizvedb in umetno napihnejo tvoje rezultate. Uporabi jih za primerjavo dveh konfiguracij med seboj, nikoli pa za razglasitev absolutne ravni kakovosti.
Celoten evalvacijski potek
Ocenjevalec zažene vsako poizvedbo iz nabora podatkov na pogonu, izračuna vse metrike za več vrednosti k in nato povpreči celoten nabor.
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}")
Sledenje več vrednostim k je samo po sebi poučno: visok recall@10 v kombinaciji s slabim recall@1 signalizira, da se pravi dokumenti najdejo, a so slabo razvrščeni – to je problem ponovnega razvrščanja, ne indeksiranja.
Primerjava dveh konfiguracij
Naslednja funkcija sooči dva pogona z istim naborom podatkov in prikaže razliko v metriki za vsako metriko posebej. Ta korak ponovi pred vsako uvedbo v proizvodno okolje, celo za spremembo, ki se zdi trivialna.
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}")
Razlike odčitaj previdno pri majhnem naboru podatkov: razlika 0,02 pri tridesetih poizvedbah je verjetno šum, medtem ko je padec recall@5 za 0,10 jasen signal, da ne smeš uvajati sprememb.
Ključne ugotovitve
- Recall@k, Precision@k, MRR in NDCG so standardne metrike
- Ustvari evalvacijski nabor podatkov s pari (poizvedba, ustrezni dokumenti)
- Avtomatiziraj generiranje poizvedb z LLM
- Sistematično primerjaj konfiguracije pred uvedbo