Przejdź do głównej treści
Polski— Wybierz język
Menu

Ocena potoku RAG

Lekcja 15 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Dwie osie oceny
  3. Metryki generowania
  4. Kompletny framework ewaluacyjny
  5. Panel metryk
  6. Kluczowe wnioski

Cele

  • Oddzielna ocena etapów wyszukiwania i generowania
  • Wdrożenie zautomatyzowanych metryk jakości RAG
  • Budowa kompletnego frameworku ewaluacyjnego

Dwie osie oceny

Potok RAG może zawieść na dwa zupełnie różne sposoby, a ich mylenie kosztuje tygodnie pracy. Albo krok wyszukiwania nie znalazł właściwych dokumentów – wtedy odpowiedź jest błędna z przyczyn niezwiązanych z modelem generującym, a metryki z Lekcji 10 to zdiagnozują – albo właściwe dokumenty były obecne, ale krok generowania poszedł nie tak: model zmyślił szczegół lub odpowiedział na inne pytanie niż zadane.

Gdy użytkownik zgłasza „odpowiedź jest błędna“, nie powie ci, która z tych dwóch przyczyn leży u podstaw. Stąd zasada: mierz oba komponenty niezależnie, używając odrębnych metryk, i dostosowuj tylko ten, który faktycznie niedomaga.

Metryki generowania

Wierność (Faithfulness) odpowiada na najważniejsze w produkcji pytanie: czy odpowiedź jest w pełni poparta dostarczonymi dokumentami, czy model dodał coś od siebie? Zamiast prosić o ogólną ocenę – którą sędziowie często wystawiają zbyt hojnie – każ im rozbić odpowiedź na poszczególne twierdzenia i sklasyfikować każde jako: poparte, niepoparte lub zaprzeczone. Ta ostatnia kategoria jest najcenniejsza: twierdzenie sprzeczne ze źródłem sygnalizuje znacznie poważniejszy błąd niż zwykłe pominięcie.

from openai import OpenAI

client = OpenAI()

def evaluate_faithfulness(
    question: str,
    answer: str,
    contexts: list[str]
) -> dict:
    """Ocena, czy odpowiedź jest wierna kontekstom."""
    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}

Odpowiedź może być idealnie wierna, a jednocześnie bezużyteczna: może wiernie kopiować fragment dotyczący czegoś innego. To właśnie mierzy trafność odpowiedzi (Answer Relevance), tym razem porównując odpowiedź wyłącznie do pytania, bez dokumentów. Prompt ustala explicitną skalę – 1,0 za odpowiedź kompletną, 0,7 za częściową, ale użyteczną, 0,3 za poboczną, 0,0 za niezwiązaną z tematem – ponieważ sędzia poproszony jedynie o „ocenę od 0 do 1“ generuje niestabilne wyniki z uruchomienia na uruchomienie.

def evaluate_relevance(question: str, answer: str) -> float:
    """Wynik trafności odpowiedzi względem pytania."""
    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

Mamy jeszcze precyzję kontekstu (Context Precision), która łączy obie osie: spośród pięciu dokumentów wstrzykniętych do promptu, ile zostało faktycznie wykorzystanych? Jeśli odpowiedź na pytanie o zasady urlopowe oparła się tylko na jednym z pięciu fragmentów, pozostałe cztery zużyły budżet kontekstu i wprowadziły szum. Pytasz więc sędziego o każdy kontekst z osobna, oczekując prostego TAK lub NIE, i obliczasz proporcję tych użytecznych.

def evaluate_context_precision(
    question: str,
    contexts: list[str],
    answer: str
) -> dict:
    """Ocena, które konteksty były przydatne dla odpowiedzi."""
    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
    }

Kompletny framework ewaluacyjny

Te trzy funkcje są bezużyteczne, dopóki pozostają manualne. Decydującym krokiem jest uruchamianie ich na stałym zestawie pytań za każdym razem, gdy modyfikujesz potok: to właśnie zamienia przeczucie – „chyba jest lepiej po zmianie chunkingu“ – w porównywalną liczbę. Poniższa klasa wykonuje potok dla każdego elementu zbioru danych, zbiera wyniki i zwraca ich średnie.

Spójrz na przykładowy zbiór danych: dwa pytania z działu HR, każde z oczekiwaną odpowiedzią i identyfikatorem dokumentów, które powinny zostać pobrane. Dwadzieścia do pięćdziesięciu wpisów tego typu, napisanych raz na zawsze na podstawie rzeczywistych pytań użytkowników, wystarczy do wykrycia regresji.

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

    def evaluate_dataset(self, dataset: list[dict]) -> dict:
        """Ocena potoku na zbiorze danych pytanie-odpowiedź.

        Każdy element: {question, expected_answer, relevant_docs}
        """
        results = {
            "faithfulness": [],
            "relevance": [],
            "context_precision": [],
        }

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

            # Ocena
            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"])

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

# Użycie
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}")

Panel metryk

Oto cele, do których warto dążyć w systemie produkcyjnym, wraz z wyjaśnieniem, co oznacza każda liczba.

MetrykaCelCo mierzy
Recall@5> 0,90Czy właściwe dokumenty są w top 5?
Precision@5> 0,70Czy zwrócone dokumenty są trafne?
Faithfulness> 0,85Czy odpowiedź jest wierna źródłom?
Answer Relevance> 0,80Czy odpowiedź dotyczy pytania?
Context Precision> 0,60Czy dostarczone konteksty są użyteczne?

Czytaj tę tabelę od góry do dołu jak drzewo diagnostyczne. Recall poniżej 0,90 sprawia, że analiza kolejnych wierszy nie ma sensu: najpierw napraw chunking lub indeks. Odwrotnie, doskonały recall przy słabej wierności wskazuje na prompt generujący, a nie na wyszukiwarkę.

Kluczowe wnioski

  • Oceniaj wyszukiwanie (recall, precyzja) i generowanie (wierność, trafność) oddzielnie
  • Wierność wykrywa halucynacje LLM
  • Trafność weryfikuje użyteczność odpowiedzi
  • Zbuduj zbiór testowy i mierz wyniki przed każdą zmianą