Otsingu kvaliteedi hindamine
Sellel lehel
Eesmärgid
- Mõista otsingu hindamise standardmõõdikuid
- Koostada hindamisandmestik
- Mõõta ja parandada oma mootori kvaliteeti
Miks hinnata?
Eelmistes tundides tutvustasime rida valikuid: manustamismudel, mõõtmete arv, tükkide suurus ja hübriidkaalutlus. Iga valik võib sinu süsteemi kas parandada või halvendada. Kolme päringu käsitsi testimisel saadud subjektiivsed muljed ei piisa otsuse tegemiseks – eriti kuna muudatus parandab sageli ühte päringute kategooriat, kuid halvendab teist. Ilma mõõdikuteta lendad pimesi.
Põhimõõdikud
Recall@k vastab küsimusele: kui suur osa asjakohastest dokumentidest ilmub k parima tulemuse hulka? See on RAG-i kullastandard, sest kontekstist puuduvat dokumenti ei saa genereerimismudel kunagi tsiteerida, ükskõik kui hea see ka poleks.
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 vaatab vastupidist: kui suur osa k tagastatud tulemusest on tegelikult asjakohane? See on kõige olulisem siis, kui LLM-ile saadetav kontekst on piiratud, kuna iga teemaväline dokument võtab ruumi ja hajutab mudeli tähelepanu.
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õõdab esimese asjakohase tulemuse järku. Esimesel kohal olev dokument saab hindeks 1, teisel kohal 0,5 ja viiendal kohal 0,2. Eelista seda mõõdikut inimestele mõeldud otsinguribade puhul, kes harva kaugemale kui esimesest kolmest reast vaatavad.
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) läheb kaugemale, loobudes binaarsest asjakohasusest: see aktsepteerib asjakohasuse astmeid, võimaldades eristada dokumenti, mis vastab küsimusele täpselt, ja dokumenti, mis puudutab seda vaid põgusalt. Nimetajas olev logaritm rakendab järku põhinevat progressiivset diskontot ja normaliseerimine ideaalse järjestuse suhtes skaalab kõik väärtused vahemikku 0 kuni 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
Hindamisandmestiku loomine
Ükski neist valemitest ei ole kasulik ilma tõese aluseta (ground truth). Hindamisandmestik seob iga päringu dokumentide loendiga, mis peaksid ilmuma, ja valikuliselt nendega, mis kindlasti ei tohiks ilmuda – viimased on kasulikud teadaolevate valepositiivsete tulemuste jälgimiseks.
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)
Kolmkümmend hästi valitud paari, mis katavad erinevat tüüpi küsimusi, mida sinu mootor tegelikult saab, on väärtuslikumad kui kolmsada massiliselt toodetud. Eelista oma otsingulogide kasutamist: need on sinu kasutajate tegelikud sõnastused, mitte need, mida sa ette kujutad.
Testpäringute genereerimine LLM-iga
Suure korpuse puhul muutub käsitsi kirjutamine ebapraktiliseks. Seega pöörame probleemi ümber: dokumentide otsimise asemel, mis vastavad küsimusele, küsime mudelilt, millistele küsimustele antud dokument vastata saab. Dokument on oma olemuselt nende küsimuste jaoks asjakohane ja saad paarid mõne minutiga.
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")
Sellel meetodil on pimekoht, mida pead teadma: genereeritud küsimused kasutavad sageli dokumendi täpset sõnavara, muutes need lihtsamaks kui tegelikud kasutajapäringud ja kunstlikult tõstes sinu tulemusi. Kasuta neid kahe konfiguratsiooni omavaheliseks võrdlemiseks, mitte absoluutse kvaliteeditaseme väljakuulutamiseks.
Täielik hindamistorustik
Hindaja käivitab iga päringu andmestikust mootoris, arvutab kõik mõõdikud mitme k väärtuse jaoks ja seejärel keskmistab kogu komplekti.
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}")
Mitme k väärtuse jälgimine on iseenesest õpetlik: kõrge recall@10 koos halva recall@1-ga annab märku, et õiged dokumendid leitakse, kuid need on halvasti järjestatud – see on ümberjärjestamise, mitte indekseerimise probleem.
Kahe konfiguratsiooni võrdlemine
Järgnev funktsioon seab kaks mootorit vastamisi sama andmestikuga ja kuvab mõõdikute vahe iga mõõdiku kohta. Korda seda sammu enne iga tootmisse viimist, isegi kui muudatus tundub tühine.
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}")
Loe deltasi väikese andmestiku puhul ettevaatlikult: 0,02 suurune vahe kolmekümne päringu üle on tõenäoliselt müra, samas kui 0,10 langus recall@5-s on selge signaal mitte kasutusele võtta.
Peamised punktid
- Recall@k, Precision@k, MRR ja NDCG on standardmõõdikud
- Loo hindamisandmestik paaridest (päring, asjakohased dokumendid)
- Automatiseeri päringute genereerimine LLM-iga
- Võrdle konfiguratsioone süstemaatiliselt enne kasutuselevõttu