Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Utvärdera en RAG-pipeline

Lektion 15 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. De två utvärderingsaxlarna
  3. Mått för generering
  4. Komplett utvärderingsramverk
  5. Mätinstrumentpanel
  6. Viktiga punkter

Mål

  • Utvärdera hämtning och generering separat
  • Implementera automatiserade kvalitetsmått för RAG
  • Bygga ett komplett utvärderingsramverk

De två utvärderingsaxlarna

En RAG-pipeline misslyckas på två helt olika sätt, och att blanda ihop dem kommer att kosta dig veckor. Antingen misslyckades hämtningen med att hitta rätt dokument – i så fall är svaret fel av skäl som inte har med genereringsmodellen att göra, och måtten från lektion 10 diagnostiserar detta – eller så fanns rätt dokument där, men genereringssteget spårade ur: modellen hittade på en detalj eller svarade på en annan fråga än den som ställdes.

När en användare rapporterar att “svaret är fel” kommer hen inte att berätta vilken av de två orsakerna som ligger bakom. Därför gäller regeln: mät båda komponenterna oberoende av varandra med distinkta mått, och justera bara en efter att du har identifierat vilken som presterar dåligt.

Mått för generering

Trovärdighet (Faithfulness) svarar på den fråga som betyder mest i produktion: är svaret helt och hållet stött av de tillhandahållna dokumenten, eller lade modellen till sitt eget spin? Istället för att be om ett globalt betyg – vilket bedömare tenderar att ge för generöst – låt bedömaren bryta ner svaret påstående för påstående och klassificera varje som stött, icke-stött eller motsatt. Den sista kategorin är den mest värdefulla: ett påstående som motsäger källan signalerar ett betydligt allvarligare fel än en enkel utelämning.

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}

Ett svar kan vara helt trovärdigt men ändå värdelöst: det kan troget kopiera ett stycke som handlar om något annat. Det är vad svarrelevans mäter, denna gång genom att jämföra svaret enbart med frågan, utan dokumenten. Prompten anger en explicit skala – 1,0 för ett komplett svar, 0,7 för ett delvis men användbart svar, 0,3 för tangentiellt, 0,0 för ovidkommande – eftersom en bedömare som bara ombes att “betygsätta från 0 till 1” producerar instabila betyg från körning till körning.

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

Sedan finns kontextprecision, som bryggar de två axlarna: av de fem dokument du matade in i prompten, hur många användes faktiskt? Om svaret på en fråga om semesterpolicy bara drog nytta av en av de fem bitarna, konsumerade de andra fyra kontextbudget och lade till brus. Så du frågar bedömaren om varje kontext isolerat, med ett enkelt ja eller nej, och beräknar andelen som var användbara.

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
    }

Komplett utvärderingsramverk

Dessa tre funktioner är värdelösa så länge de förblir manuella. Det avgörande steget är att köra dem på en fast uppsättning frågor varje gång du modifierar pipelinen: det är det som förvandlar en magkänsla – “Jag tror att det är bättre sedan jag ändrade chunkingen” – till ett jämförbart tal. Klassen nedan exekverar pipelinen på varje objekt i datasetet, samlar in betygen och returnerar deras medelvärden.

Titta på exempeldatasetet: två HR-frågor, var och en med ett förväntat svar och identifieraren för de dokument som borde hämtas. Tjugo till femtio poster av denna typ, skrivna en gång för alla från verkliga användarfrågor, räcker för att upptäcka 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}")

Mätinstrumentpanel

Här är målen att sikta på i ett produktionssystem, tillsammans med vad varje tal faktiskt betyder.

MåttMålVad det mäter
Recall@5> 0,90Finns rätt dokument bland de 5 bästa?
Precision@5> 0,70Är de returnerade dokumenten relevanta?
Trovärdighet> 0,85Är svaret troget källorna?
Svarrelevans> 0,80Besvarar svaret frågan?
Kontextprecision> 0,60Är de tillhandahållna kontexterna användbara?

Läs denna tabell uppifrån och ner som ett diagnostiskt träd. Ett recall under 0,90 gör varje analys av de följande raderna meningslös: åtgärda chunkingen eller indexet först. Omvänt pekar utmärkt recall kombinerat med dålig trovärdighet på genereringsprompten, inte sökningen.

Viktiga punkter

  • Utvärdera hämtning (recall, precision) och generering (trovärdighet, relevans) separat
  • Trovärdighet upptäcker LLM-hallucinationer
  • Relevans verifierar att svaret är användbart
  • Bygg ett testdataset och mät före varje ändring