Een RAG-pijplijn evalueren
Op deze pagina
Doelstellingen
- Retrieval en generatie afzonderlijk evalueren
- Geautomatiseerde RAG-kwaliteitsmetrics implementeren
- Een compleet evaluatiekader opbouwen
De twee assen van evaluatie
Een RAG-pijplijn faalt op twee zeer verschillende manieren, en ze door elkaar halen kost u weken. Ofwel faalde de retrieval-stap in het vinden van de juiste documenten—in welk geval het antwoord fout is om redenen die niets te maken hebben met het generatiemodel, en de metrics uit Les 10 dit zullen diagnosticeren—ofwel waren de juiste documenten aanwezig, maar sloeg de generatie-stap volledig de plank mis: het model verzon een detail of beantwoordde een andere vraag dan gesteld.
Wanneer een gebruiker meldt dat “het antwoord fout is”, zal deze u niet vertellen welke van de twee oorzaken speelt. Vandaar de regel: meet beide componenten onafhankelijk met distincte metrics, en pas pas iets aan nadat u hebt geïdentificeerd welke component ondermaats presteert.
Generatie-metrics
Faithfulness (trouw) beantwoordt de vraag die in productie het belangrijkst is: wordt het antwoord volledig ondersteund door de verstrekte documenten, of heeft het model er zijn eigen draai aan gegeven? Vraag niet om een globale score—beoordelaars zijn daar vaak te gul mee—maar laat de beoordelaar het antwoord claim voor claim ontleden en elke claim classificeren als ondersteund, niet-ondersteund of tegengesproken. Die laatste categorie is het waardevolst: een claim die de bron tegenspreekt, signaleert een veel ernstigere fout dan een simpele omissie.
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}
Een antwoord kan perfect trouw zijn en toch nutteloos: het kan bijvoorbeeld een passage trouw kopiëren die over iets anders gaat. Dat is wat answer relevance (antwoordrelevantie) meet, waarbij dit keer alleen het antwoord met de vraag wordt vergeleken, zonder de documenten. De prompt stelt een expliciete schaal in—1,0 voor een compleet antwoord, 0,7 voor een gedeeltelijk maar nuttig antwoord, 0,3 voor zijdelings verwant, 0,0 voor off-topic—omdat een beoordelaar die simpelweg wordt gevraagd om “een score van 0 tot 1 te geven”, van run tot run instabiele scores produceert.
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
Dan is er nog context precision (contextprecisie), dat de twee assen overbrugt: van de vijf documenten die u in de prompt hebt opgenomen, hoeveel zijn er daadwerkelijk gebruikt? Als het antwoord op een vraag over verlofbeleid slechts één van de vijf chunks gebruikte, consumeerden de andere vier contextbudget en voegden ze ruis toe. U vraagt de beoordelaar dus over elke context afzonderlijk, met een simpel ja of nee, en berekent het aandeel dat nuttig was.
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
}
Compleet evaluatiekader
Deze drie functies zijn nutteloos zolang ze handmatig blijven. De beslissende stap is om ze bij elke wijziging in de pijplijn op een vaste set vragen uit te voeren: dat is wat een onderbuikgevoel—“Ik denk dat het beter is sinds ik de chunking heb veranderd”—omzet in een vergelijkbaar getal. De onderstaande klasse voert de pijplijn uit op elk item in de dataset, verzamelt de scores en retourneert de gemiddelden.
Bekijk de voorbeelddataset: twee HR-vragen, elk met een verwacht antwoord en de identifier van de documenten die opgehaald moeten worden. Twintig tot vijftig entries van dit type, eenmalig geschreven op basis van echte gebruikersvragen, volstaan om regressies op te sporen.
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}")
Metrics-dashboard
Hier zijn de streefwaarden voor een productiesysteem, samen met de betekenis van elk getal.
| Metric | Streefwaarde | Wat het meet |
|---|---|---|
| Recall@5 | > 0,90 | Zitten de juiste docs in de top 5? |
| Precision@5 | > 0,70 | Zijn de geretourneerde docs relevant? |
| Faithfulness | > 0,85 | Is het antwoord trouw aan de bronnen? |
| Answer Relevance | > 0,80 | Beantwoordt het antwoord de vraag? |
| Context Precision | > 0,60 | Zijn de verstrekte contexten nuttig? |
Lees deze tabel van boven naar beneden als een diagnostische boom. Een recall lager dan 0,90 maakt elke analyse van de volgende regels zinloos: los eerst de chunking of de index op. Een uitstekende recall gecombineerd met een slechte faithfulness wijst daarentegen op de generatie-prompt, niet op de zoekopdracht.
Belangrijkste punten
- Evalueer retrieval (recall, precisie) en generatie (trouw, relevantie) afzonderlijk
- Faithfulness detecteert LLM-hallucinaties
- Relevance verifieert dat het antwoord nuttig is
- Bouw een testdataset op en meet voor elke wijziging