Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Evaluér søgekvalitet

Lektion 10 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Hvorfor evaluere?
  3. Nøglemålinger
  4. Opret et evalueringssæt
  5. Komplet evalueringspipeline
  6. Sammenlign to konfigurationer
  7. Vigtige pointer

Mål

  • Forstå standardmålinger til evaluering af søgning
  • Opbyg et evalueringssæt
  • Mål og forbedr din engines kvalitet

Hvorfor evaluere?

Tidligere lektioner introducerede en række valg: indlejringsmodel, antal dimensioner, chunk-størrelse og hybrid vægtning. Hvert valg kan forbedre eller forringe dit system. Subjektive indtryk fra manuel test af tre forespørgsler er ikke nok til at træffe en beslutning – især fordi en ændring ofte forbedrer én kategori af forespørgsler, mens den forringer en anden. Uden målinger flyver du blindt.

Nøglemålinger

Recall@k besvarer dette spørgsmål: blandt de relevante dokumenter, hvor mange optræder i de øverste k resultater? Dette er guldstandarden for RAG, fordi et dokument, der mangler i konteksten, aldrig kan citeres af generationsmodellen, uanset hvor god den er.

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 ser på det omvendte: blandt de k returnerede resultater, hvor mange er faktisk relevante? Dette er vigtigst, når konteksten sendt til LLM’en er begrænset, da ethvert irrelevant dokument optager plads og udvander modellens opmærksomhed.

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åler rangen af det første relevante resultat. Et dokument på førstepladsen scorer 1, på andenpladsen 0,5 og på femtepladsen 0,2. Prioriter denne måling for søgebjælker beregnet til mennesker, der sjældent kigger ud over de første tre linjer.

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) går videre ved at opgive binær relevans: den accepterer grader af relevans, så du kan skelne mellem et dokument, der besvarer spørgsmålet præcist, og et der kun strejfer emnet. Logaritmen i nævneren anvender en progressiv rabat baseret på rang, og normalisering i forhold til den ideelle rangering skalerer alt mellem 0 og 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

Opret et evalueringssæt

Ingen af disse formler er nyttige uden sandhedsgrundlag (ground truth). Et evalueringssæt knytter hver forespørgsel til listen over dokumenter, der bør vises, og eventuelt dem der bestemt ikke bør – sidstnævnte er nyttige til at overvåge kendte falske positiver.

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)

Tredive velvalgte par, der dækker de forskellige typer spørgsmål, din engine faktisk modtager, er mere værd end tre hundrede masseproducerede. Prioriter at trække fra dine søgelogge: dette er dine brugeres faktiske formuleringer, ikke dem du forestiller dig.

Generér testforespørgsler med en LLM

På et stort korpus bliver manuel skrivning upraktisk. Så vi vender problemet på hovedet: i stedet for at lede efter dokumenter, der besvarer et spørgsmål, spørger vi en model, hvilke spørgsmål et givent dokument kan adressere. Dokumentet er per konstruktion relevant for disse spørgsmål, og du får par på få minutter.

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

Denne metode har et blindt punkt, du skal kende: genererede spørgsmål genbruger ofte dokumentets nøjagtige ordforråd, hvilket gør dem lettere end rigtige brugerforespørgsler og kunstigt oppuster dine scorer. Brug dem til at sammenligne to konfigurationer med hinanden, aldrig til at erklære et absolut kvalitetsniveau.

Komplet evalueringspipeline

Evaluatoren kører hver forespørgsel fra sættet på enginen, beregner alle målinger for flere værdier af k og gennemsnitter derefter hele sættet.

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

At spore flere værdier af k er i sig selv instruktivt: en høj recall@10 parret med en dårlig recall@1 signalerer, at de rigtige dokumenter findes, men er dårligt rangeret – et omrangeringsproblem, ikke et indekseringsproblem.

Sammenlign to konfigurationer

Den følgende funktion sætter to engines op mod hinanden på samme sæt og viser målingsforskellen per metrik. Gentag dette trin før hver produktionssætning, selv for en ændring, der virker triviel.

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

Læs deltas forsigtigt på et lille sæt: et gab på 0,02 over tredive forespørgsler er sandsynligvis støj, hvorimod et fald i recall@5 på 0,10 er et klart signal om ikke at deploye.

Vigtige pointer

  • Recall@k, Precision@k, MRR og NDCG er standardmålingerne
  • Opret et evalueringssæt med (forespørgsel, relevante dokumenter)-par
  • Automatisér generering af forespørgsler med en LLM
  • Sammenlign systematisk konfigurationer før deploy