Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A keresés minőségének értékelése

10. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Miért érdemes értékelni?
  3. Kulcsfontosságú metrikák
  4. Értékelő adatkészlet létrehozása
  5. Teljes értékelési folyamat
  6. Két konfiguráció összehasonlítása
  7. Főbb megállapítások

Célok

  • Ismerd meg a szabványos keresésértékelési metrikákat
  • Készíts értékelő adatkészletet
  • Mérd és javítsd a motorod minőségét

Miért érdemes értékelni?

Az előző leckék számos döntési lehetőséget mutattak be: beágyazási modell, dimenziók száma, darabolási méret és hibrid súlyozás. Minden egyes választás javíthat vagy ronthat a rendszereden. Három lekérdezés manuális teszteléséből származó szubjektív benyomások nem elegendők a döntéshez – különösen azért, mert egy változtatás gyakran javít a lekérdezések egyik kategóriáján, miközben ront egy másikon. Metrikák nélkül vakon repülsz.

Kulcsfontosságú metrikák

A Recall@k (találati arány) arra a kérdésre válaszol: a releváns dokumentumok közül hány jelenik meg a top k találat között? Ez az aranystandard metrika a RAG rendszerek számára, mert egy olyan dokumentum, amely hiányzik a kontextusból, sosem lesz hivatkozva a generáló modell által, bármilyen jó legyen is az.

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

A Precision@k (pontosság) az ellenkezőjét vizsgálja: a visszaadott k találat közül hány valóban releváns? Ez akkor a legfontosabb, ha az LLM-nek küldött kontextus korlátozott, mivel minden témán kívüli dokumentum helyet foglal el és hígítja a modell figyelmét.

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

Az MRR (Mean Reciprocal Rank – Átlagos reciprok rangsor) az első releváns találat rangsorát méri. Az első helyen lévő dokumentum 1 pontot kap, a másodikon lévő 0,5-öt, az ötödiken lévő pedig 0,2-t. Ezt a metrikát előnyben kell részesíteni az embereknek szánt keresősávok esetén, akik ritkán néznek tovább az első három sornál.

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

Az NDCG@k (Normalized Discounted Cumulative Gain – Normalizált diszkontált kumulatív nyereség) tovább megy, elvetve a bináris relevanciát: elfogadja a relevancia fokozatait, lehetővé téve, hogy különbséget tegyél egy olyan dokumentum között, amely pontosan megválaszolja a kérdést, és egy olyan között, amely csak érintőlegesen foglalkozik vele. A nevezőben lévő logaritmus a rangsor alapján progresszív csökkentést alkalmaz, míg az ideális rangsorhoz való normalizálás 0 és 1 közé skáláz mindent.

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

Értékelő adatkészlet létrehozása

Ezen képletek egyike sem hasznos földi igazság (ground truth) nélkül. Egy értékelő adatkészlet minden lekérdezéshez hozzárendeli azon dokumentumok listáját, amelyeknek meg kell jelenniük, és opcionálisan azokat, amelyeknek biztosan nem – ez utóbbiak hasznosak az ismert hamis pozitív eredmények monitorozásához.

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)

Harminc jól megválasztott pár, amely lefedi a motorod által ténylegesen kapott kérdéstípusokat, többet ér, mint háromszáz tömeggyártott. Előnyben részesítsd a keresési naplóidból való kinyerést: ezek a felhasználóid tényleges megfogalmazásai, nem pedig azok, amelyeket te képzelsz el.

Tesztlekérdezések generálása LLM-mel

Nagy korpusz esetén a manuális írás kivitelezhetetlenné válik. Ezért megfordítjuk a problémát: ahelyett, hogy olyan dokumentumokat keresnénk, amelyek válaszolnak egy kérdésre, megkérdezünk egy modellt, hogy milyen kérdésekre tud választ adni egy adott dokumentum. A dokumentum szerkezeténél fogva releváns ezekre a kérdésekre, és percek alatt párokat kapsz.

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

Ennek a módszernek van egy vakfoltja, amit ismerned kell: a generált kérdések gyakran pontosan újrahasználják a dokumentum szókincsét, így könnyebbek, mint a valós felhasználói lekérdezések, és mesterségesen felfújják a pontszámaidat. Használd őket két konfiguráció egymáshoz viszonyított összehasonlítására, soha nem abszolút minőségi szint deklarálására.

Teljes értékelési folyamat

Az értékelő lefuttatja az adatkészlet minden lekérdezését a motoron, kiszámolja az összes metrikát több k értékre, majd átlagolja az egész halmazt.

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

Több k érték nyomon követése önmagában is tanulságos: egy magas recall@10 egy gyenge recall@1 mellett azt jelzi, hogy a megfelelő dokumentumokat megtalálják, de rosszul rangsorolják – ez újrarangsorolási probléma, nem indexelési probléma.

Két konfiguráció összehasonlítása

Az alábbi függvény két motort állít szembe ugyanazon adatkészlettel, és megjeleníti a metrikák közötti különbséget metricánként. Ismételd meg ezt a lépést minden élesítés előtt, még akkor is, ha a változtatás triviálisnak tűnik.

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

Óvatosan olvasd a deltákat kis adatkészleten: egy 0,02-es különbség harminc lekérdezésen valószínűleg zaj, míg egy 0,10-es visszaesés a recall@5-ben egyértelmű jelzés arra, hogy ne telepítsd a rendszert.

Főbb megállapítások

  • A Recall@k, Precision@k, MRR és NDCG a szabványos metrikák
  • Készíts értékelő adatkészletet (lekérdezés, releváns dokumentumok) párokkal
  • Automatizáld a lekérdezések generálását LLM-mel
  • Rendszeresen hasonlítsd össze a konfigurációkat telepítés előtt