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

Оценяване на вашите подкани: методи, оценители и миграция към Promptfoo

Урок 15 от 20 Обновен 3 ноември 2026 г. Напреднало
На тази страница
  1. Защо трябва да оценявате систематично
  2. Изградете набор от данни, който прилича на реалния свят
  3. Изберете правилния оценител
  4. Сглобете пълното оценяване
  5. Индустриализирайте с Promptfoo
  6. Ключови изводи

Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите temperature и top_p се приемат само при усилие за разсъждение (reasoning effort) със стойност none, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Заявките, които задават тези параметри, следователно трябва да уточняват reasoning={"effort": "none"} (Responses API) или reasoning_effort="none" (Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.

Актуализация от 2 ноември 2026 г. — Платформа Evals. OpenAI обяви прекратяването на своята платформа Evals: съществуващите оценки са само за четене от 31 октомври 2026 г., а таблото за управление заедно с API ще бъдат затворени на 30 ноември 2026 г., включително оценителите (graders). OpenAI публикува ръководство за миграция към Promptfoo. Принципите за оценяване в този урок остават валидни; променя се единствено инструментът.

Защо трябва да оценявате систематично

Не можете да подобрите това, което не измервате. Когато промените подкана, модел или параметър, как разбирате дали качеството действително се е подобрило? Спонтанният метод е да тествате три или четири примера, да откриете по-добрите отговори и да ги внедрите. Това често се проваля, защото тестваните примери са точно онези, които са причинили проблеми миналата седмица: измервате подобрение там, където сте го търсили, и пропускате регресии, въведени в случаи, които вече са работили добре.

Оценките (evals) превръщат тази интуиция в обективна мярка. До 2026 г. OpenAI предлагаше интегрирана платформа за това – Evals; тя е в режим само за четене от 31 октомври 2026 г. и ще бъде затворена на 30 ноември. OpenAI сега препоръчва Promptfoo, инструмент с отворен код за оценяване и „червен отбор“ (red teaming). Добрата новина е, че и двете споделят едни и същи градивни елементи – тестови данни, подкани, модели и критерии за оценяване. Това, което научавате тук чрез Python код, се пренася директно, а последната част на урока показва преминаването към Promptfoo.

Три концепции структурират целия процес. Наборът от данни (dataset) е съвкупност от тестови случаи с входове и очаквани изходи: това е вашият ориентир, еквивалентът на набор от модулни тестове. Оценителят (grader) е критерий за оценка – точно съвпадение, LLM като съдия, оценка – който решава дали даден отговор е добър. Изпълнението (run) е изпълнение на оценяване върху набор от данни с конкретен модел и подкана; това е единицата, която сравнявате от една версия към следващата.

Изградете набор от данни, който прилича на реалния свят

Един тестов случай се състои от вход, очакван изход и метаданни. Последните не са декоративни: те са това, което ще ви позволи да осъзнаете впоследствие, че обща оценка от 87% крие срив в категорията „код“, компенсиран от отлични резултати в географията. Без категория или трудност разполагате само с агрегирано число, а агрегираното число никога не ви казва къде да intervenирате.

import json

# A dataset is a list of test cases
dataset = [
    {
        "input": "What is the capital of France?",
        "expected": "Paris",
        "metadata": {"category": "geography", "difficulty": "easy"},
    },
    {
        "input": "Explain Bayes' theorem in one sentence.",
        "expected": "Bayes' theorem calculates the probability "
                    "of an event based on known conditional probabilities.",
        "metadata": {"category": "mathematics", "difficulty": "medium"},
    },
    {
        "input": "Write a Python function that reverses a list.",
        "expected": "def reverse_list(lst): return lst[::-1]",
        "metadata": {"category": "code", "difficulty": "easy"},
    },
]

# Save as JSONL
with open("eval_dataset.jsonl", "w") as f:
    for case in dataset:
        f.write(json.dumps(case, ensure_ascii=False) + "\n")

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

import openai
import random

client = openai.OpenAI()

def create_dataset_from_logs(
    production_logs: list[dict],
    sample_size: int = 100,
) -> list[dict]:
    """Creates an evaluation dataset from production logs."""
    # Sample
    sample = random.sample(
        production_logs,
        min(sample_size, len(production_logs)),
    )

    dataset = []
    for log in sample:
        dataset.append({
            "input": log["prompt"],
            "expected": log["validated_response"],  # Response validated by a human
            "metadata": {
                "source": "production",
                "date": log["date"],
                "original_model": log["model"],
            },
        })

    return dataset

Изберете правилния оценител

Оценителят за точно съвпадение (exact match) е най-строгият и най-бързият. Той подхожда само за задачи, при които изходът е ограничен: класификация в три категории, извличане на номер на фактура, отговор „да“ или „не“. Използван върху свободен текст, той би дал нула на перфектен отговор, просто формулиран различно от референтния.

def exact_grader(response: str, expected: str) -> dict:
    """Evaluates if the response matches exactly."""
    score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
    return {"score": score, "type": "exact"}

Оценителят за включване (inclusion grader) отпуска ограничението: той проверява наличието на очаквани ключови думи и връща частична оценка. Това е правилният инструмент за отговори, които трябва да обхващат задължителни точки, без формулировката да има значение – например отговор на поддръжка, който трябва да спомене срока за отказ и адреса за връщане. Неговата слабост е добре известна: текст, съдържащ правилните думи в абсурден ред, би получил перфектна оценка.

def inclusion_grader(response: str, keywords: list[str]) -> dict:
    """Checks that the response contains the expected keywords."""
    response_lower = response.lower()
    found = sum(1 for word in keywords if word.lower() in response_lower)
    score = found / len(keywords) if keywords else 0.0
    return {
        "score": score,
        "found": found,
        "total": len(keywords),
        "type": "inclusion",
    }

След това идва най-мощният: друг LLM оценява качеството на отговора. Оценителят LLM-as-Judge оценява това, което никое механично правило не може – яснота, пълнота, точност на тона. Два детайла от изпълнението го правят практичен. Първо, temperature=0.0: без това една и съща съдия би присъдила различни оценки на един и същ отговор от едно изпълнение до друго и вашият бенчмарк би загубил цялата си сравнителна стойност. Второ, резервният механизъм за json.JSONDecodeError: съдия, която коментира вместо да върне JSON, не трябва да срива цялата кампания.

def llm_judge_grader(
    question: str,
    response: str,
    expected: str,
    criteria: str = "accuracy, completeness, clarity",
) -> dict:
    """Uses an LLM to evaluate response quality."""
    judge_prompt = f"""Rate the quality of this response on a scale of 1 to 5.

Question: {question}
Expected Response: {expected}
Response to Evaluate: {response}

Criteria: {criteria}

Respond ONLY with JSON:
{{"score": <1-5>, "justification": "<short explanation>"}}"""

    response_obj = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=judge_prompt,
        temperature=0.0,
    )

    import json
    try:
        result = json.loads(response_obj.output_text)
        result["normalized_score"] = result["score"] / 5.0
        return result
    except json.JSONDecodeError:
        return {"score": 0, "justification": "Parsing error", "normalized_score": 0}

Сглобете пълното оценяване

Оркестрацията не представлява концептуална трудност: преминавате през набора от данни, извиквате модела със системната подкана за тестване, прилагате оценителя и агрегирате резултатите. Интересното е, че функцията за оценяване идва като параметър, което ви позволява да изпълните отново абсолютно същия набор от данни с различни критерии в зависимост от кампанията – включване за бърза проверка по време на разработка, LLM съдия за валидиране преди производство.

async def run_eval(
    dataset: list[dict],
    model: str,
    system_prompt: str,
    grader_fn,
) -> dict:
    """Runs a full evaluation on a dataset."""
    results = []

    for case in dataset:
        response = client.responses.create(
            model=model,
            instructions=system_prompt,
            input=case["input"],
        )

        score = grader_fn(response.output_text, case["expected"])
        results.append({
            "input": case["input"],
            "expected": case["expected"],
            "obtained": response.output_text,
            **score,
        })

    # Calculate aggregated metrics
    scores = [r["score"] for r in results if "score" in r]
    return {
        "model": model,
        "num_cases": len(dataset),
        "average_score": sum(scores) / len(scores) if scores else 0,
        "min_score": min(scores) if scores else 0,
        "max_score": max(scores) if scores else 0,
        "results": results,
    }

Отчетът запазва min_score и детайлите за всеки случай и това е умишлено. Средната стойност ви казва дали се движите напред; случаите с най-лоша оценка ви казват защо. Направете си навик да четете петте най-лоши отговора от всяко изпълнение, преди да коментирате средната стойност: точно там, и рядко другаде, ще откриете следващата поправка, която трябва да направите.

Индустриализирайте с Promptfoo

Писането на вашите оценки на ръка в Python е поучително; поддържането им във времето е по-удобно със специализиран инструмент. Ръководството за миграция на OpenAI описва логиката на Promptfoo: оценяването живее в конфигурационен файл, promptfooconfig.yaml, който обединява подкани, модел(и), тестови случаи и критерии – тук наречени твърдения (assertions). Той се изпълнява от командния ред, локално или във вашата непрекъсната интеграция, и съществува редом с кода на приложението.

description: Support ticket classification
prompts:
  - "Classify this ticket into a single category (billing, technical, account): {{ticket}}"
providers:
  - openai:gpt-6.1-sol
tests:
  - vars:
      ticket: "My card was charged twice this month."
    assert:
      - type: icontains
        value: billing
  - vars:
      ticket: "The app crashes when I open a PDF."
    assert:
      - type: icontains
        value: technical
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
promptfoo validate config -c promptfooconfig.yaml   # in case of configuration error

Оценителите в този урок се появяват отново като твърдения: точно съвпадение, включване на ключови думи и преценка от модел. OpenAI предупреждава относно последната точка: възсъздаден оценител, особено LLM съдия, трябва да бъде ревалидиран, преди да се използва за вземане на решение за регресия, тъй като оценките няма непременно да са идентични от един инструмент към друг.

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

  • Оценките превръщат интуицията в обективна мярка за качество
  • Създавайте своите набори от данни от реални производствени случаи, валидирани от човек
  • Изберете оценителя въз основа на задачата: точен за ограничени, включване за задължителни точки, LLM-as-Judge за нюанси
  • Задайте temperature=0.0 на съдията, за да направите оценките възпроизводими
  • Изпълнявайте оценки преди всяка промяна на подканата или модела
  • Платформата Evals на OpenAI се затваря на 30 ноември 2026 г.: Promptfoo, препоръчан от OpenAI, поема наборите от данни, подканите, моделите и критериите в конфигурационен файл