Премини към основното съдържание
Български— Изберете език
Меню

Оценяване на RAG конвейер

Урок 15 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Двете оси на оценяване
  3. Метрики за генериране
  4. Цялостна рамка за оценяване
  5. Табло с метрики
  6. Ключови изводи

Цели

  • Оценяване на извличането и генерирането поотделно
  • Внедряване на автоматизирани метрики за качество на RAG
  • Изграждане на цялостна рамка за оценяване

Двете оси на оценяване

Един RAG конвейер се проваля по два много различни начина и объркването им ще Ви коства седмици. Или стъпката за извличане не е успяла да намери правилните документи – в този случай отговорът е грешен поради причини, несвързани с модела за генериране, и метриките от Урок 10 ще диагностицират това – или правилните документи са били налични, но стъпката за генериране е излязла от релси: моделът е измислил детайл или е отговорил на различен въпрос от зададения.

Когато потребител съобщи, че „отговорът е грешен“, той няма да Ви каже коя от двете причини е в игра. Оттук и правилото: измервайте двата компонента независимо с различни метрики и коригирайте само единия, след като сте идентифицирали кой от тях работи под очакванията.

Метрики за генериране

Верността (Faithfulness) отговаря на най-важния въпрос в производствена среда: отговорът изцяло ли се подкрепя от предоставените документи или моделът е добавил собствен щрих? Вместо да искате глобална оценка – която оценителите склонни да дават твърде щедро – накарайте оценителя да разбие отговора на твърдение по твърдение и да класифицира всяко като подкрепено, неподкрепено или опровергано. Последната категория е най-ценна: твърдение, което противоречи на източника, сигнализира за много по-сериозна грешка от обикновено пропускане.

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}

Един отговор може да бъде напълно верен, но безполезен: той може да копира дословно пасаж, който се отнася за нещо друго. Това измерва релевантността на отговора, като този път сравнява отговора само с въпроса, без документите. Промптът задава ясна скала – 1,0 за пълен отговор, 0,7 за частичен, но полезен отговор, 0,3 за косвено свързан, 0,0 за извън темата – защото оценител, помолен просто да „оцени от 0 до 1“, произвежда нестабилни резултати от едно изпълнение до друго.

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

След това идва прецизността на контекста, която свързва двете оси: от петте документа, които сте инжектирали в промпта, колко всъщност са използвани? Ако отговорът на въпрос относно политиката за отпуски се е основал само на един от петте чънка, другите четири са изконсумирали бюджет за контекст и са добавили шум. Затова питате оценителя за всеки контекст поотделно с просто „да“ или „не“ и изчислявате пропорцията на полезните.

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
    }

Цялостна рамка за оценяване

Тези три функции са безполезни, докато остават ръчни. Решаващата стъпка е да ги стартирате върху фиксиран набор от въпроси всеки път, когато модифицирате конвейера: това е, което превръща усещането – „Мисля, че е по-добре, след като промених разделянето на чънкове“ – в сравнимо число. Класът по-долу изпълнява конвейера за всеки елемент в набора от данни, събира оценките и връща техните средни стойности.

Разгледайте примерния набор от данни: два HR въпроса, всеки с очакван отговор и идентификатор на документите, които трябва да бъдат извлечени. Двадесет до петдесет записа от този тип, написани веднъж завинаги въз основа на реални потребителски въпроси, са достатъчни, за да откриете регресии.

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}")

Табло с метрики

Ето целевите стойности, към които трябва да се стремите в производствена система, заедно с това какво означава всяко число.

МетрикаЦелКакво измерва
Recall@5> 0.90Правилните документи ли са в топ 5?
Precision@5> 0.70Върнатите документи релевантни ли са?
Faithfulness> 0.85Отговорът верен ли е спрямо източниците?
Answer Relevance> 0.80Отговорът адресира ли въпроса?
Context Precision> 0.60Предоставените контексти полезни ли са?

Прочетете тази таблица отгоре надолу като диагностично дърво. Стойност на recall под 0,90 прави всеки анализ на следващите редове безсмислен: първо поправете разделянето на чънкове или индекса. Обратно, отличен recall, съчетан с лоша верност, насочва към промпта за генериране, а не към търсенето.

Ключови изводи

  • Оценявайте извличането (recall, precision) и генерирането (верност, релевантност) поотделно
  • Верността открива халюцинации на LLM
  • Релевантността проверява дали отговорът е полезен
  • Изградете тестов набор от данни и измервайте преди всяка промяна