Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Vyhodnotenie kvality vyhľadávania

Lekcia 10 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Prečo hodnotiť?
  3. Kľúčové metriky
  4. Vytvorenie hodnotiaceho datasetu
  5. Kompletný pipeline hodnotenia
  6. Porovnanie dvoch konfigurácií
  7. Kľúčové poznatky

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