Evaluarea unui flux RAG
Pe această pagină
Obiective
- Evaluați separat recuperarea și generarea
- Implementați metrici automate de calitate pentru RAG
- Construiți un cadru complet de evaluare
Cele două axe ale evaluării
Un flux RAG poate eșua în două moduri foarte diferite, iar confundarea lor vă va costa săptămâni întregi. Fie pasul de recuperare nu a reușit să găsească documentele corecte — caz în care răspunsul este greșit din motive nelegate de modelul de generare, iar metricile din Lecția 10 vor diagnostica această problemă — fie documentele corecte erau prezente, dar pasul de generare a luat-o razna: modelul a inventat un detaliu sau a răspuns la o altă întrebare decât cea pusă.
Când un utilizator raportează „răspunsul este greșit“, nu vă va spune care dintre cele două cauze este la originea problemei. De aici regula: măsurați ambele componente independent, cu metrici distincte, și modificați una singură după ce ați identificat care dintre ele subperformează.
Metrici de generare
Fidelitatea răspunde la întrebarea cea mai importantă în producție: este răspunsul susținut integral de documentele furnizate sau modelul și-a adăugat propria interpretare? În loc să cereți un scor global — pe care evaluatorii tind să îl acorde prea generos — cereți evaluatorului să descompună răspunsul afirmație cu afirmație și să clasifice fiecare ca fiind susținută, nesusținută sau contrazisă. Această ultimă categorie este cea mai valoroasă: o afirmație care contrazice sursa semnalează o eroare mult mai gravă decât o simplă omisiune.
from openai import OpenAI
client = OpenAI()
def evaluate_faithfulness(
question: str,
answer: str,
contexts: list[str]
) -> dict:
"""Evaluează dacă răspunsul este fidel contextelor."""
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}
Un răspuns poate fi perfect fidel, dar inutil: ar putea copia fidel un pasaj care tratează cu totul altceva. Acest lucru este măsurat de relevanța răspunsului, comparând de data aceasta răspunsul doar cu întrebarea, fără documente. Promptul stabilește o scară explicită — 1,0 pentru un răspuns complet, 0,7 pentru un răspuns parțial dar util, 0,3 pentru tangențial, 0,0 pentru subiect nepotrivit — deoarece un evaluator căruia i se cere simplu să „noteze de la 0 la 1“ produce scoruri instabile de la o execuție la alta.
def evaluate_relevance(question: str, answer: str) -> float:
"""Scor de relevanță al răspunsului în raport cu întrebarea."""
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
Apoi există precizia contextului, care face legătura între cele două axe: dintre cele cinci documente pe care le-ați injectat în prompt, câte au fost folosite efectiv? Dacă răspunsul la o întrebare despre politicile de concediu s-a bazat doar pe unul dintre cele cinci fragmente, celelalte patru au consumat bugetul de context și au adăugat zgomot. Așadar, întrebați evaluatorul despre fiecare context în izolare, cu un simplu da sau nu, și calculați proporția celor care au fost utile.
def evaluate_context_precision(
question: str,
contexts: list[str],
answer: str
) -> dict:
"""Evaluează care contexte au fost utile pentru răspuns."""
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
}
Cadru complet de evaluare
Aceste trei funcții sunt inutile atâta timp cât rămân manuale. Pasul decisiv este rularea lor pe un set fix de întrebări de fiecare dată când modificați fluxul: asta transformă o intuiție — „Cred că e mai bine de când am schimbat fragmentarea“ — într-un număr comparabil. Clasa de mai jos execută fluxul pe fiecare element din setul de date, colectează scorurile și returnează mediile acestora.
Priviți setul de date exemplu: două întrebări HR, fiecare cu un răspuns așteptat și identificatorul documentelor care ar trebui recuperate. Douăzeci până la cincizeci de intrări de acest tip, scrise o dată pentru totdeauna pe baza unor întrebări reale ale utilizatorilor, sunt suficiente pentru a detecta regresii.
class RAGEvaluator:
def __init__(self, rag_pipeline):
self.pipeline = rag_pipeline
self.client = OpenAI()
def evaluate_dataset(self, dataset: list[dict]) -> dict:
"""Evaluează fluxul pe un set de date întrebare-răspuns.
Fiecare element: {question, expected_answer, relevant_docs}
"""
results = {
"faithfulness": [],
"relevance": [],
"context_precision": [],
}
for item in dataset:
# Execută fluxul
output = self.pipeline.respond(item["question"])
answer = output["answer"]
contexts = [s["excerpt"] for s in output["sources"]]
# Evaluează
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"])
# Medii
import numpy as np
return {
metric: round(float(np.mean(scores)), 4)
for metric, scores in results.items()
}
# Utilizare
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}")
Tablou de bord al metricilor
Iată țintele pe care trebuie să le vizați într-un sistem de producție, împreună cu semnificația fiecărui număr.
| Metrică | Țintă | Ce măsoară |
|---|---|---|
| Recall@5 | > 0,90 | Sunt documentele corecte în top 5? |
| Precision@5 | > 0,70 | Sunt documentele returnate relevante? |
| Fidelitate | > 0,85 | Este răspunsul fidel surselor? |
| Relevanța răspunsului | > 0,80 | Răspunde răspunsul la întrebare? |
| Precizia contextului | > 0,60 | Sunt contextele furnizate utile? |
Citiți acest tabel de sus în jos ca pe un arbore de diagnosticare. Un recall sub 0,90 face orice analiză a liniilor următoare inutilă: reparați mai întâi fragmentarea sau indexul. Invers, un recall excelent asociat cu o fidelitate slabă indică o problemă la promptul de generare, nu la căutare.
Puncte cheie
- Evaluați separat recuperarea (recall, precizie) și generarea (fidelitate, relevanță)
- Fidelitatea detectează halucinațiile LLM
- Relevanța verifică utilitatea răspunsului
- Construiți un set de date de test și măsurați performanța înainte de fiecare modificare