Vyhodnocení RAG pipeline
Na této stránce
Cíle
- Vyhodnotit vyhledávání (retrieval) a generování odděleně
- Implementovat automatizované metriky kvality RAG
- Vytvořit kompletní rámec pro evaluaci
Dvě osy evaluace
RAG pipeline selhává dvěma velmi odlišnými způsoby a jejich zaměňování tě bude stát týdny práce. Buď selhal krok vyhledávání (retrieval) a nenašel správné dokumenty – v tom případě je odpověď špatná z důvodů nesouvisejících s modelem pro generování a diagnostikují to metriky z Lekce 10 – nebo byly správné dokumenty přítomny, ale krok generování se vymkl kontrole: model si vymyslel detail nebo odpověděl na jinou otázku, než která byla položena.
Když uživatel nahlásí „odpověď je špatná“, neřekne ti, která z těchto dvou příčin je na vině. Proto platí pravidlo: měř obě komponenty nezávisle pomocí odlišných metrik a laděním se zabývej až poté, co identifikuješ, která z nich podává horší výkon.
Metriky generování
Věrnost (Faithfulness) odpovídá na otázku, která je v produkci nejdůležitější: je odpověď plně podložena poskytnutými dokumenty, nebo si model přidal vlastní interpretaci? Místo žádosti o celkové skóre – které hodnotitelé mají tendenci udělovat příliš štědře – nech hodnotitele rozklíčovat odpověď tvrzení od tvrzení a každé klasifikovat jako podložené, nepodložené nebo vyvrácené. Ta poslední kategorie je nejcennější: tvrzení, které je v rozporu se zdrojem, signalizuje mnohem vážnější chybu než pouhé vynechání informace.
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}
Odpověď může být dokonale věrná, a přesto k ničemu: může věrně kopírovat pasáž, která se týká něčeho jiného. To měří relevance odpovědi, která tentokrát porovnává odpověď pouze s otázkou, bez dokumentů. Prompt stanoví explicitní škálu – 1,0 za úplnou odpověď, 0,7 za částečnou, ale užitečnou, 0,3 za okrajovou souvislost, 0,0 za téma mimo – protože hodnotitel požádaný pouze o „ohodnocení od 0 do 1“ produkuje nestabilní skóre od běhu k běhu.
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
Pak tu máme přesnost kontextu (context precision), která propojuje obě osy: z pěti dokumentů, které jsi vložil do promptu, kolik jich bylo skutečně využito? Pokud odpověď na otázku týkající se dovolených politik čerpala pouze z jednoho z pěti chunků, zbývající čtyři spotřebovaly rozpočet kontextu a přidaly šum. Proto se hodnotitele ptáš na každý kontext izolovaně s jednoduchou odpovědí ano/ne a vypočítáš podíl těch užitečných.
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",
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
}
Kompletní rámec pro evaluaci
Tyto tři funkce jsou k ničemu, pokud zůstanou manuální. Rozhodujícím krokem je spustit je při každé úpravě pipeline na pevné sadě otázek: právě to promění pocit typu „myslím, že je to lepší, protože jsem změnil chunkování“ na porovnatelné číslo. Níže uvedená třída spustí pipeline pro každou položku v datasetu, sesbírá skóre a vrátí jejich průměry.
Podívej se na ukázkový dataset: dvě otázky z oblasti HR, každá s očekávanou odpovědí a identifikátorem dokumentů, které by měly být vyhledány. Dvacet až padesát položek tohoto typu, napsaných jednou provždy na základě reálných uživatelských otázek, stačí k odhalení regrese.
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 metrik
Zde jsou cíle, na které bys měl v produkčním systému mířit, spolu s vysvětlením, co každé číslo skutečně znamená.
| Metrika | Cíl | Co měří |
|---|---|---|
| Recall@5 | > 0,90 | Jsou správné dokumenty v top 5? |
| Precision@5 | > 0,70 | Jsou vrácené dokumenty relevantní? |
| Faithfulness | > 0,85 | Je odpověď věrná zdrojům? |
| Answer Relevance | > 0,80 | Odpovídá odpověď na otázku? |
| Context Precision | > 0,60 | Jsou poskytnuté kontexty užitečné? |
Čti tuto tabulku shora dolů jako diagnostický strom. Recall pod 0,90 činí jakoukoli analýzu následujících řádků bezpředmětnou: nejprve oprav chunkování nebo index. Naopak vynikající recall v kombinaci se špatnou věrností ukazuje na prompt pro generování, nikoliv na vyhledávání.
Klíčové poznatky
- Vyhodnocuj vyhledávání (recall, precision) a generování (věrnost, relevance) odděleně
- Věrnost odhaluje halucinace LLM
- Relevance ověřuje, zda je odpověď užitečná
- Vytvoř testovací dataset a měř před každou změnou