Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Novērtēt meklēšanas kvalitāti

Nodarbība 10 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Kāpēc novērtēt?
  3. Galvenās metrikas
  4. Novērtēšanas datu kopas izveide
  5. Pilns novērtēšanas process
  6. Divu konfigurāciju salīdzināšana
  7. Galvenās atziņas

Mērķi

  • Izprast standarta meklēšanas novērtēšanas metrikas
  • Izveidot novērtēšanas datu kopu
  • Izmērīt un uzlabot sava dzinēja kvalitāti

Kāpēc novērtēt?

Iepriekšējās nodarbībās tika apskatīta virkne izvēļu: iegulšanas (embedding) modelis, dimensiju skaits, fragmenta izmērs un hibrīda svērumi. Katra izvēle var uzlabot vai pasliktināt tavu sistēmu. Subjektīvi iespaidi, manuāli pārbaudot trīs vaicājumus, nav pietiekami lēmuma pieņemšanai — it īpaši tāpēc, ka izmaiņas bieži uzlabo vienu vaicājumu kategoriju, vienlaikus pasliktinot citu. Bez metrikām tu lido akli.

Galvenās metrikas

Recall@k atbild uz jautājumu: cik liela daļa no attiecīgajiem dokumentiem parādās k labāko rezultātu vidū? Šī ir zelta standarta metrika RAG sistēmām, jo dokuments, kas trūkst kontekstā, nekad netiks citēts ģenerēšanas modelī, neatkarīgi no tā, cik labs tas ir.

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 aplūko pretējo: cik liela daļa no k atgrieztajiem rezultātiem patiesībā ir attiecīgi? Tas ir vissvarīgākajā brīdī, kad LLM nosūtītais konteksts ir ierobežots, jo katrs ārpus tēmas esošs dokuments aizņem vietu un izkliedē modeļa uzmanību.

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ēra pirmā attiecīgā rezultāta rangu. Dokuments pirmajā vietā iegūst 1, otrajā — 0,5, bet piektajā — 0,2. Dod priekšroku šai metrikai meklēšanas joslām, kas paredzētas cilvēkiem, kuri reti skatās tālāk par pirmajām trim rindām.

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) iet tālāk, atsakoties no binārās attiecīguma koncepcijas: tas pieļauj attiecīguma pakāpes, ļaujot nošķirt dokumentu, kas precīzi atbild uz jautājumu, no tāda, kas tikai pieskaras tēmai. Logaritms saucējā piemēro progresīvu atlaidi atkarībā no ranga, un normalizācija pret ideālo rangējumu visu mērogo starp 0 un 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

Novērtēšanas datu kopas izveide

Neviena no šīm formulām nav noderīga bez patiesības pamata (ground truth). Novērtēšanas datu kopa sasaista katru vaicājumu ar to dokumentu sarakstu, kuriem vajadzētu parādīties, un, pēc izvēles, ar tiem, kuriem noteikti nevajadzētu parādīties — pēdējie ir noderīgi zināmu viltus pozitīvo rezultātu uzraudzībai.

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)

Trīsdesmit labi izvēlēti pāri, kas aptver dažādus jautājumu veidus, kurus tavs dzinējs faktiski saņem, ir vērtīgāki nekā trīs simti masveidā ģenerētu. Dod priekšroku datu ieguvei no saviem meklēšanas žurnāliem: tie ir tavi lietotāju faktiskie formulējumi, nevis tie, kurus tu iztēlojies.

Testa vaicājumu ģenerēšana, izmantojot LLM

Lielā korpusā manuāla rakstīšana kļūst nepraktiska. Tāpēc mēs apgriežam problēmu otrādi: tā vietā, lai meklētu dokumentus, kas atbild uz jautājumu, mēs jautājam modelim, uz kādiem jautājumiem konkrēts dokuments varētu atbildēt. Dokuments pēc konstrukcijas ir attiecīgs uz šiem jautājumiem, un tu iegūsti pārus dažu minūšu laikā.

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")

Šai metodei ir akls punkts, kas tev jāzina: ģenerētie jautājumi bieži atkārto dokumenta precīzo vārdu krājumu, padarot tos vieglākus nekā reāli lietotāju vaicājumi un mākslīgi paaugstinot tavus rezultātus. Izmanto tos, lai salīdzinātu divas konfigurācijas savā starpā, bet nekad, lai deklarētu absolūtu kvalitātes līmeni.

Pilns novērtēšanas process

Novērtētājs izpilda katru vaicājumu no datu kopas dzinējā, aprēķina visas metrikas vairākām k vērtībām un pēc tam aprēķina visu kopu vidējo rādītāju.

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}")

Vairāku k vērtību izsekošana pati par sevi ir pamācoša: augsts recall@10 apvienojumā ar sliktu recall@1 liecina, ka pareizie dokumenti tiek atrasti, bet slikti rangēti — tā ir pārrangēšanas (reranking) problēma, nevis indeksēšanas problēma.

Divu konfigurāciju salīdzināšana

Tālāk redzamā funkcija nostata divus dzinējus vienu pret otru vienā un tajā pašā datu kopā un parāda metrikas starpību katrai metrikai. Atkārto šo soli pirms katras izvietošanas ražošanas vidē, pat ja izmaiņas šķiet niecīgas.

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}")

Lasiet deltas uzmanīgi, strādājot ar mazu datu kopu: 0,02 starpība trīsdesmit vaicājumos, visticamāk, ir troksnis, savukārt 0,10 kritums recall@5 ir skaidrs signāls neizvietot sistēmu.

Galvenās atziņas

  • Recall@k, Precision@k, MRR un NDCG ir standarta metrikas
  • Izveido novērtēšanas datu kopu ar pāriem (vaicājums, attiecīgie dokumenti)
  • Automatizē vaicājumu ģenerēšanu, izmantojot LLM
  • Sistemātiski salīdzini konfigurācijas pirms izvietošanas