Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

De zoekkwaliteit evalueren

Les 10 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Waarom evalueren?
  3. Belangrijkste metrieken
  4. Een evaluatiedataset maken
  5. Volledige evaluatiepijplijn
  6. Twee configuraties vergelijken
  7. Belangrijkste punten

Doelstellingen

  • De standaardmetrieken voor zoekevaluatie begrijpen
  • Een evaluatiedataset opbouwen
  • De kwaliteit van uw engine meten en verbeteren

Waarom evalueren?

Eerdere lessen introduceerden een reeks keuzes: embedding-model, aantal dimensies, chunk-grootte en hybride weging. Elke keuze kan uw systeem verbeteren of verslechteren. Subjectieve indrukken op basis van het handmatig testen van drie query’s zijn niet voldoende om een beslissing te nemen—zeker omdat een wijziging vaak de ene categorie query’s verbetert terwijl een andere verslechtert. Zonder metrieken vliegt u blind.

Belangrijkste metrieken

Recall@k beantwoordt deze vraag: van de relevante documenten, hoeveel verschijnen er in de top k resultaten? Dit is de gouden standaardmetriek voor RAG, omdat een document dat ontbreekt in de context nooit door het generatiemodel kan worden geciteerd, hoe goed het ook is.

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 kijkt naar het omgekeerde: van de k teruggegeven resultaten, hoeveel zijn daadwerkelijk relevant? Dit is vooral belangrijk wanneer de context die naar de LLM wordt verzonden beperkt is, omdat elk off-topic document ruimte inneemt en de aandacht van het model verdunt.

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) meet de rang van het eerste relevante resultaat. Een document op de eerste plaats scoort 1, op de tweede plaats 0,5 en op de vijfde plaats 0,2. Geef prioriteit aan deze metriek voor zoekbalken die voor mensen zijn bedoeld, omdat ze zelden verder kijken dan de eerste drie regels.

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) gaat verder door binaire relevantie los te laten: het accepteert gradaties van relevantie, waardoor u onderscheid kunt maken tussen een document dat de vraag exact beantwoordt en een document dat er slechts kort op ingaat. De logaritme in de noemer past een progressieve korting toe op basis van de rang, en normalisatie ten opzichte van de ideale rangschikking schaalt alles tussen 0 en 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

Een evaluatiedataset maken

Geen van deze formules is nuttig zonder grondwaarheid. Een evaluatiedataset koppelt elke query aan de lijst documenten die moeten verschijnen, en optioneel aan die welke dat zeker niet moeten—deze laatste zijn nuttig voor het monitoren van bekende false positives.

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)

Dertig goed gekozen paren die de verschillende soorten vragen dekken die uw engine daadwerkelijk ontvangt, zijn meer waard dan driehonderd massaal geproduceerde. Geef prioriteit aan het halen van gegevens uit uw zoeklogs: dit zijn de daadwerkelijke formuleringen van uw gebruikers, niet die welke u zich voorstelt.

Testquery’s genereren met een LLM

Bij een groot corpus wordt handmatig schrijven onpraktisch. We draaien het probleem daarom om: in plaats van te zoeken naar documenten die een vraag beantwoorden, vragen we een model welke vragen een bepaald document kan behandelen. Het document is per constructie relevant voor deze vragen, en u heeft binnen enkele minuten paren.

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

Deze methode heeft een blind vlek die u moet kennen: gegenereerde vragen gebruiken vaak exact hetzelfde vocabulaire als het document, waardoor ze gemakkelijker zijn dan echte gebruikersquery’s en uw scores kunstmatig verhogen. Gebruik ze om twee configuraties met elkaar te vergelijken, nooit om een absoluut kwaliteitsniveau vast te stellen.

Volledige evaluatiepijplijn

De evaluator voert elke query uit de dataset uit op de engine, berekent alle metrieken voor verschillende waarden van k en middelt vervolgens de hele set.

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

Het volgen van meerdere waarden van k is op zichzelf al instructief: een hoge recall@10 gecombineerd met een slechte recall@1 signaleert dat de juiste documenten wel worden gevonden, maar slecht gerangschikt—een herordeningsprobleem, geen indexeringsprobleem.

Twee configuraties vergelijken

De volgende functie zet twee engines tegen elkaar op dezelfde dataset en toont het metriekverschil per metriek. Herhaal deze stap voor elke productie-implementatie, zelfs voor een wijziging die triviaal lijkt.

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

Lees delta’s voorzichtig bij een kleine dataset: een verschil van 0,02 over dertig query’s is waarschijnlijk ruis, terwijl een daling van 0,10 in recall@5 een duidelijk signaal is om niet te implementeren.

Belangrijkste punten

  • Recall@k, Precision@k, MRR en NDCG zijn de standaardmetrieken
  • Maak een evaluatiedataset met paren van (query, relevante documenten)
  • Automatiseer het genereren van query’s met een LLM
  • Vergelijk configuraties systematisch voordat u implementeert