Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Oceni kakovost iskanja

Lekcija 10 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Zakaj ocenjevati?
  3. Ključne metrike
  4. Ustvari evalvacijski nabor podatkov
  5. Celoten evalvacijski potek
  6. Primerjava dveh konfiguracij
  7. Ključne ugotovitve

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