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

Оценка на вашите агенти: Метрики и бенчмаркове

Урок 22 от 25 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Оценка на вашите агенти: Метрики и бенчмаркове
  2. Защо да оценявате?
  3. Основни метрики
  4. Оценка чрез LLM (LLM-as-Judge)
  5. Структурирани тестови комплекти
  6. Ключови изводи

Оценка на вашите агенти: Метрики и бенчмаркове

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

Защо да оценявате?

Без формална оценка действате на сляпо. Преформулирате инструкция, защото потребител се е оплакал, но нищо не ви подсказва дали агентът се е подобрил или просто сте счупили три други сценария. Колебаете се между Terra и Luna за вашия случай на употреба – или между два нива на разсъждение на един и същи модел – и без измервания решението се основава на интуиция след пет ръчни опита. Променяте схемата на инструмент, агентът спира да го използва в конкретен случай и никой не забелязва, докато броят на tiketите не скочи рязко. Един оценъчен комплект превръща всяка от тези ситуации в сравнимо число от една версия към следващата.

Основни метрики

Точност (Accuracy)

Първият въпрос е най-директен: дава ли агентът правилния отговор? Възпроизвеждате набор от въпроси, за които знаете отговора, и проверявате наличието му в изхода. Сравняването на поднизове без отчитане на главни и малки букви е умишлено грубо – то толерира „Лаптопът Pro струва 1299 евро с ДДС“, където строгото равенство би се провалило – но е достатъчно за проверими факти и се изчислява за секунда.

from agents import Agent, Runner

async def evaluate_accuracy(agent, test_cases):
    results = []
    for case in test_cases:
        result = await Runner.run(agent, case["question"])
        # Automatic or LLM-based verification
        is_correct = case["expected_answer"].lower() in result.final_output.lower()
        results.append({
            "question": case["question"],
            "answer": result.final_output,
            "expected": case["expected_answer"],
            "correct": is_correct,
        })

    rate = sum(1 for r in results if r["correct"]) / len(results)
    print(f"Accuracy: {rate:.1%} ({sum(1 for r in results if r['correct'])}/{len(results)})")
    return results

# Test suite
test_cases = [
    {"question": "What is the price of the Pro laptop?", "expected_answer": "1299"},
    {"question": "How many laptops are in stock?", "expected_answer": "45"},
    {"question": "What is the cheapest product?", "expected_answer": "tablet"},
]

Правилно използване на инструментите

Правилен отговор, получен случайно, остава проблем. Агент, който рецитира запомнена цена вместо да queried каталога, ще премине теста за точност днес и ще даде остаряла ставка утре. Втората метрика следователно разглежда пътя, а не резултата: извиква ли агентът правилните инструменти с правилните аргументи? Четете извикванията в raw_responses, филтрирайки за изходи от тип function_call, а сравнението използва множества (sets), за да остане безразлично към реда.

async def evaluate_tools(agent, test_cases):
    results = []
    for case in test_cases:
        result = await Runner.run(agent, case["question"])

        # Extract called tools from raw responses
        called_tools = []
        for response in result.raw_responses:
            for output in getattr(response, "output", []):
                if hasattr(output, "type") and output.type == "function_call":
                    called_tools.append(output.name)

        tools_correct = set(case["expected_tools"]) == set(called_tools)
        results.append({
            "question": case["question"],
            "called_tools": called_tools,
            "expected_tools": case["expected_tools"],
            "correct": tools_correct,
        })

    rate = sum(1 for r in results if r["correct"]) / len(results)
    print(f"Correct tools: {rate:.1%}")
    return results

tool_cases = [
    {
        "question": "What is the price of the laptop?",
        "expected_tools": ["search_product"],
    },
    {
        "question": "Price of the laptop with 10% discount",
        "expected_tools": ["search_product", "calculate_discount"],
    },
]

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

Латентност и разходи

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

import time

async def evaluate_performance(agent, messages, iterations=10):
    latencies = []
    for message in messages:
        for _ in range(iterations):
            start = time.perf_counter()
            result = await Runner.run(agent, message)
            duration = time.perf_counter() - start
            latencies.append(duration)

    import statistics
    print(f"Average latency: {statistics.mean(latencies):.2f}s")
    print(f"P50 latency: {statistics.median(latencies):.2f}s")
    print(f"P99 latency: {sorted(latencies)[int(len(latencies) * 0.99)]:.2f}s")

Оценка чрез LLM (LLM-as-Judge)

Тези три метрики пропускат всичко, което няма един единствен правилен отговор: обяснение на политика за връщане, преформулиране на продажба, съобщение с извинение. За тези отговори с отворен край използвайте модел за оценка на качеството. Съдията получава въпроса и отговора, прилага критерии, които сте написали – точност, релевантност, професионализъм – и връща структурирана оценка благодарение на Pydantic output_type. Ограничението на формата е това, което прави процеса използваем: получавате агрегируемо цяло число, а не коментар за повторно четене.

from pydantic import BaseModel

class Evaluation(BaseModel):
    score: int  # 1-5
    reason: str
    is_correct: bool
    is_relevant: bool
    is_professional: bool

evaluator_agent = Agent(
    name="Evaluator",
    instructions="""Evaluate the quality of the agent's response.
    Criteria:
    - Accuracy: Is the response factual and correct?
    - Relevance: Does the response answer the question asked?
    - Professionalism: Is the tone appropriate?
    Score from 1 (very poor) to 5 (excellent).""",
    model="gpt-5.6-sol",
    output_type=Evaluation,
)

async def evaluate_quality(question, agent_response):
    prompt = f"""Question asked: {question}
    Agent response: {agent_response}
    Evaluate this response."""

    result = await Runner.run(evaluator_agent, prompt)
    return result.final_output

Полето reason заслужава вниманието ви по време на прегледите: тук съдията обяснява защо е дал оценка 3 от 5 и често това е формулировката на недостатък, който не сте успели да назовете.

Структурирани тестови комплекти

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

import json

# evaluation_dataset.json
DATASET = [
    {
        "id": "test_001",
        "category": "price",
        "question": "What is the price of the Pro laptop?",
        "expected_answer": "€1,299",
        "expected_tools": ["search_product"],
        "criteria": ["contains_price", "professional_tone"],
    },
    {
        "id": "test_002",
        "category": "stock",
        "question": "Is the Tablet Air in stock?",
        "expected_answer": "yes",
        "expected_tools": ["search_product"],
        "criteria": ["clear_answer", "stock_information"],
    },
]

async def run_complete_evaluation(agent):
    results = []
    for case in DATASET:
        result = await Runner.run(agent, case["question"])
        eval_result = await evaluate_quality(case["question"], result.final_output)
        results.append({
            **case,
            "agent_response": result.final_output,
            "score": eval_result.score,
            "evaluation": eval_result.reason,
        })

    # Report
    average_score = sum(r["score"] for r in results) / len(results)
    print(f"\nAverage score: {average_score:.1f}/5")
    for cat in set(r["category"] for r in results):
        cat_scores = [r["score"] for r in results if r["category"] == cat]
        print(f"  {cat}: {sum(cat_scores)/len(cat_scores):.1f}/5")

    return results

Изпълнявайте тази оценка във вашия CI/CD конвейер, точно както вашите модулни тестове, и задайте праг, под който доставката се блокира. От този момент нататък всяка промяна – нов модел, коригирани инструкции, добавен инструмент – се сравнява с предишната върху едни и същи случаи и дискусията спира да се върти около впечатления.

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

  • Оценявайте точността, използването на инструменти, латентността и разходите
  • Оценката чрез LLM (LLM-as-Judge) обработва отговорите с отворен край
  • Създавайте структурирани и възпроизводими тестови комплекти
  • Автоматизирайте оценяването във вашия CI/CD, за да откривате регресии
  • Систематично сравнявайте промените (модел, инструкции, инструменти)