Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Vyhodnocení kvality vyhledávání

Lekce 10 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Proč vyhodnocovat?
  3. Klíčové metriky
  4. Vytvoření evaluačního datasetu
  5. Kompletní evaluační pipeline
  6. Porovnání dvou konfigurací
  7. Klíčové poznatky

Cíle

  • Porozumět standardním metrikám pro hodnocení vyhledávání
  • Vytvořit evaluační dataset
  • Změřit a zlepšit kvalitu tvého engine

Proč vyhodnocovat?

Předchozí lekce představily řadu voleb: model pro embeddingy, počet dimenzí, velikost chunku a váhy hybridního vyhledávání. Každá volba může tvůj systém zlepšit nebo zhoršit. Subjektivní dojmy z ručního otestování tří dotazů nestačí k rozhodnutí – zejména proto, že změna často zlepší jednu kategorii dotazů, zatímco jinou zhorší. Bez metrik létáš naslepo.

Klíčové metriky

Recall@k odpovídá na otázku: kolik relevantních dokumentů se objeví v top $k$ výsledcích? Toto je zlatý standard pro RAG, protože dokument chybějící v kontextu nemůže generační model nikdy citovat, ať je sebelepší.

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 se dívá na opak: kolik z vrácených $k$ výsledků je skutečně relevantních? To je nejdůležitější, když je kontext posílaný do LLM omezený, protože každý dokument mimo téma zabírá místo a rozptyluje pozornost 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) měří pořadí prvního relevantního výsledku. Dokument na prvním místě získá 1, na druhém 0,5 a na pátém 0,2. Tuto metriku upřednostni pro vyhledávací pole určená lidem, kteří zřídka hledají dál než za prvními třemi řádky.

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) jde ještě dál tím, že opouští binární relevanci: přijímá stupně relevance, což ti umožňuje rozlišit mezi dokumentem, který přesně odpovídá na otázku, a tím, který se jí jen dotýká. Logaritmus ve jmenovateli aplikuje progresivní diskontování podle pořadí a normalizace vůči ideálnímu řazení škáluje vše mezi 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

Vytvoření evaluačního datasetu

Žádný z těchto vzorců není užitečný bez ground truth. Evaluační dataset přiřazuje každému dotazu seznam dokumentů, které by se měly objevit, a volitelně i ty, které by se rozhodně objevit neměly – ty druhé jsou užitečné pro monitorování známých falešných pozitiv.

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)

Třicet dobře vybraných párů pokrývajících různé typy otázek, které tvůj engine skutečně dostává, má větší hodnotu než tři sta masově vyrobených. Upřednostni čerpání z tvých vyhledávacích logů: jsou to skutečná formulace tvých uživatelů, ne ta, která si představuješ.

Generování testovacích dotazů pomocí LLM

U velkého korpusu se ruční psaní stává nepraktickým. Proto problém otočíme: místo hledání dokumentů, které odpovídají na otázku, se zeptáme modelu, na jaké otázky může daný dokument odpovědět. Dokument je díky konstrukci pro tyto otázky relevantní a páry získáš během minut.

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

Tato metoda má slepé místo, které musíš znát: generované otázky často znovu používají přesnou slovní zásobu dokumentu, což je činí snazšími než skutečné uživatelské dotazy a uměle nafukuje tvá skóre. Používej je k porovnání dvou konfigurací navzájem, nikdy k prohlášení absolutní úrovně kvality.

Kompletní evaluační pipeline

Evaluátor spustí každý dotaz z datasetu na enginu, vypočítá všechny metriky pro několik hodnot $k$ a následně zprůměruje celou sadu.

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

Sledování více hodnot $k$ je samo o sobě poučné: vysoký recall@10 v kombinaci se špatným recall@1 signalizuje, že správné dokumenty jsou nacházeny, ale špatně řazeny – jde o problém s rerankingem, ne s indexováním.

Porovnání dvou konfigurací

Následující funkce postaví proti sobě dva enginy na stejném datasetu a zobrazí rozdíl v metrikách pro každou metriku. Tento krok opakuj před každým nasazením do produkce, i když se změna zdá triviální.

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

Čti delty opatrně u malého datasetu: rozdíl 0,02 u třiceti dotazů je pravděpodobně šum, zatímco pokles recall@5 o 0,10 je jasný signál k nenasazování.

Klíčové poznatky

  • Recall@k, Precision@k, MRR a NDCG jsou standardní metriky
  • Vytvoř evaluační dataset s páry (dotaz, relevantní dokumenty)
  • Automatizuj generování dotazů pomocí LLM
  • Systematicky porovnávej konfigurace před nasazením