Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Evaluér en RAG-pipeline

Lektion 15 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. De to akser for evaluering
  3. Målinger for generering
  4. Komplet evalueringsframework
  5. Dashboard for målinger
  6. Vigtige pointer

Mål

  • Evaluér hentning (retrieval) og generering hver for sig
  • Implementér automatiserede kvalitetsmålinger for RAG
  • Byg et komplet evalueringsframework

De to akser for evaluering

En RAG-pipeline kan fejle på to vidt forskellige måder, og at forveksle dem vil koste dig uger. Enten fejlede hentnings-trinnet i at finde de rigtige dokumenter – i så fald er svaret forkert af årsager, der ikke har noget med genereringsmodellen at gøre, og målingerne fra lektion 10 vil diagnosticere dette – eller også var de rigtige dokumenter til stede, men genererings-trinnet løb løbsk: modellen opfandt en detalje eller besvarede et andet spørgsmål end det, der blev stillet.

Når en bruger rapporterer “svaret er forkert”, vil de ikke fortælle dig, hvilken af de to årsager der er på spil. Derfor gælder reglen: mål begge komponenter uafhængigt med forskellige målinger, og justér først den ene, når du har identificeret, hvilken der underpræsterer.

Målinger for generering

Trofasthed (faithfulness) besvarer det spørgsmål, der betyder mest i produktion: er svaret fuldt ud understøttet af de leverede dokumenter, eller har modellen tilføjet sit eget spin? I stedet for at bede om en global score – som bedømmere ofte giver for generøst – skal du få bedømmeren til at opdele svaret påstand for påstand og klassificere hver som understøttet, ikke-understøttet eller modsagt. Den sidste kategori er den mest værdifulde: en påstand, der modsiger kilden, signalerer en langt mere alvorlig fejl end en simpel udeladelse.

from openai import OpenAI

client = OpenAI()

def evaluate_faithfulness(
    question: str,
    answer: str,
    contexts: list[str]
) -> dict:
    """Evaluates whether the answer is faithful to the contexts."""
    full_context = "\n\n---\n\n".join(contexts)

    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Evaluate the faithfulness of this answer relative to the "
                f"source documents.\n\n"
                f"Source documents:\n{full_context}\n\n"
                f"Question: {question}\n\n"
                f"Answer: {answer}\n\n"
                f"For each claim in the answer, indicate:\n"
                f"- SUPPORTED: if confirmed by the documents\n"
                f"- UNSUPPORTED: if it does not appear in the documents\n"
                f"- CONTRADICTED: if it contradicts the documents\n\n"
                f"End with a global score from 0 to 1."
            )
        }],
        temperature=0
    )
    return {"evaluation": response.choices[0].message.content}

Et svar kan være perfekt trofast, men alligevel ubrugeligt: det kan trofast kopiere et afsnit, der handler om noget andet. Det er det, svar-relevans måler; denne gang sammenlignes svaret kun med spørgsmålet, uden dokumenterne. Prompten fastsætter en eksplicit skala – 1,0 for et komplet svar, 0,7 for et delvist men brugbart svar, 0,3 for tangentielt, 0,0 for off-topic – fordi en bedømmer, der blot bliver bedt om at “vurdere fra 0 til 1”, producerer ustabile scores fra kørsel til kørsel.

def evaluate_relevance(question: str, answer: str) -> float:
    """Relevance score of the answer relative to the question."""
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"On a scale of 0 to 1, how well does this answer "
                f"address the question asked?\n\n"
                f"Question: {question}\n"
                f"Answer: {answer}\n\n"
                f"Criteria:\n"
                f"- 1.0: complete and precise answer\n"
                f"- 0.7: partial but useful answer\n"
                f"- 0.3: tangentially related\n"
                f"- 0.0: off-topic\n\n"
                f"Return only the numeric score."
            )
        }],
        temperature=0,
        max_tokens=10
    )
    try:
        return float(response.choices[0].message.content.strip())
    except ValueError:
        return 0.0

Så er der kontekst-præcision, som forbinder de to akser: blandt de fem dokumenter, du injicerede i prompten, hvor mange blev faktisk brugt? Hvis svaret på et spørgsmål om feriepolitikker kun trak på ét af de fem chunks, brugte de andre fire kontekst-budget og tilføjede støj. Så du spørger bedømmeren om hver kontekst isoleret set med et simpelt ja eller nej og beregner den andel, der var nyttig.

def evaluate_context_precision(
    question: str,
    contexts: list[str],
    answer: str
) -> dict:
    """Evaluates which contexts were useful for the answer."""
    results = []

    for i, ctx in enumerate(contexts):
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"Was this document useful for answering "
                    f"the question?\n\n"
                    f"Question: {question}\n"
                    f"Document: {ctx[:500]}\n"
                    f"Generated answer: {answer}\n\n"
                    f"Answer YES or NO."
                )
            }],
            temperature=0,
            max_tokens=5
        )
        useful = "yes" in response.choices[0].message.content.lower()
        results.append({"index": i, "useful": useful})

    num_useful = sum(1 for r in results if r["useful"])
    return {
        "details": results,
        "precision": num_useful / len(contexts) if contexts else 0
    }

Komplet evalueringsframework

Disse tre funktioner er ubrugelige, så længe de forbliver manuelle. Det afgørende skridt er at køre dem på et fast sæt spørgsmål hver gang, du modificerer pipeline: det er det, der omdanner en mavefornemmelse – „Jeg tror, det er bedre, siden jeg ændrede chunking” – til et sammenligneligt tal. Klassen nedenfor eksekverer pipeline på hvert element i datasættet, indsamler scorerne og returnerer deres gennemsnit.

Se på eksempel-datasættet: to HR-spørgsmål, hver med et forventet svar og identifikatoren for de dokumenter, der bør hentes. Tyve til halvtreds poster af denne type, skrevet én gang for alle ud fra rigtige brugerspørgsmål, er nok til at opdage regressioner.

class RAGEvaluator:
    def __init__(self, rag_pipeline):
        self.pipeline = rag_pipeline
        self.client = OpenAI()

    def evaluate_dataset(self, dataset: list[dict]) -> dict:
        """Evaluates the pipeline on a question-answer dataset.

        Each item: {question, expected_answer, relevant_docs}
        """
        results = {
            "faithfulness": [],
            "relevance": [],
            "context_precision": [],
        }

        for item in dataset:
            # Execute the pipeline
            output = self.pipeline.respond(item["question"])
            answer = output["answer"]
            contexts = [s["excerpt"] for s in output["sources"]]

            # Evaluate
            relevance = evaluate_relevance(item["question"], answer)
            results["relevance"].append(relevance)

            ctx_eval = evaluate_context_precision(
                item["question"], contexts, answer
            )
            results["context_precision"].append(ctx_eval["precision"])

        # Averages
        import numpy as np
        return {
            metric: round(float(np.mean(scores)), 4)
            for metric, scores in results.items()
        }

# Usage
dataset = [
    {
        "question": "How many leave days do I have?",
        "expected_answer": "25 days of paid leave per year",
        "relevant_docs": ["leave-policy"]
    },
    {
        "question": "Can I work remotely on Mondays?",
        "expected_answer": "Yes, remote work is allowed except on Tuesdays and Thursdays",
        "relevant_docs": ["remote-work-policy"]
    },
]

evaluator = RAGEvaluator(rag_pipeline)
metrics = evaluator.evaluate_dataset(dataset)
print("Results:")
for k, v in metrics.items():
    print(f"  {k}: {v}")

Dashboard for målinger

Her er målene, du skal sigte efter i et produktionssystem, sammen med hvad hvert tal faktisk betyder.

MålingMålHvad den måler
Recall@5> 0,90Er de rigtige docs i top 5?
Precision@5> 0,70Er de returnerede docs relevante?
Trofasthed> 0,85Er svaret trofast over for kilderne?
Svar-relevans> 0,80Besvarer svaret spørgsmålet?
Kontekst-præcision> 0,60Er de leverede kontekster nyttige?

Læs denne tabel fra top til bund som et diagnostisk træ. En recall under 0,90 gør enhver analyse af de følgende linjer meningsløs: fix chunking eller indekset først. Omvendt peger fremragende recall parret med dårlig trofasthed på genererings-prompten, ikke søgningen.

Vigtige pointer

  • Evaluér hentning (recall, præcision) og generering (trofasthed, relevans) hver for sig
  • Trofasthed opdager LLM-hallucinationer
  • Relevans verificerer, at svaret er nyttigt
  • Byg et test-datasæt og mål før hver ændring