Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Hodnocení vašich agentů: Metriky a benchmarky

Lekce 22 z 25 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Hodnocení vašich agentů: Metriky a benchmarky
  2. Proč hodnotit?
  3. Klíčové metriky
  4. Hodnocení pomocí LLM (LLM-as-Judge)
  5. Strukturované testovací sady
  6. Klíčové poznatky

Hodnocení vašich agentů: Metriky a benchmarky

Agent, který funguje ve vývojovém prostředí, může v produkci selhat. Systematické hodnocení je jediným způsobem, jak zaručit kvalitu před nasazením i po něm. V této lekci se naučíš definovat metriky, vytvářet testovací sady a automatizovat evaluaci.

Proč hodnotit?

Bez formálního hodnocení létáš naslepo. Přeformuluješ instrukci, protože si uživatel stěžoval, ale nic ti neřekne, zda se agent zlepšil, nebo jestli jsi právě nerozbil tři jiné scénáře. Váháš mezi Terrou a Lunou pro svůj use case – nebo mezi dvěma úrovněmi uvažování na stejném modelu – a bez měření se rozhoduješ podle pocitu po pěti ručních zkouškách. Změníš schéma nástroje, agent ho přestane v určitém případě volat a nikdo si toho nevšimne, dokud nevyskočí počet ticketů. Evaluační sada promění každou z těchto situací v porovnatelné číslo od jedné verze k druhé.

Klíčové metriky

Přesnost

První otázka je ta nejpřímější: odpovídá agent správně? Přehraješ sadu otázek, u kterých znáš odpověď, a ověříš její přítomnost ve výstupu. Porovnání podřetězců bez rozlišení velkých a malých písmen je záměrně hrubé – toleruje větu „Notebook Pro stojí 1 299 € včetně DPH“, kde by striktní rovnost selhala – ale pro ověřitelná fakta stačí a výpočet zabere vteřinu.

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"},
]

Správné použití nástrojů

Správná odpověď získaná náhodou zůstává problémem. Agent, který odříká zapamatovanou cenu místo dotazu do katalogu, dnes projde testem přesnosti a zítra vrátí zastaralou sazbu. Druhá metrika se proto dívá na cestu, ne na výsledek: volá agent správné nástroje se správnými argumenty? Čteš volání v raw_responses, filtruješ výstupy function_call a porovnání používá množiny, aby bylo lhostejné k pořadí.

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"],
    },
]

Druhý testovací případ je nejpoučnější: otázka vyžaduje řetězení dvou nástrojů a přesně toto druh kompozice může změna v popisu tiše rozbít.

Latence a náklady

Nakonec tu je operační rozměr. Průměr nic neříká o reálné zkušenosti: uživatele odrazuje ocas rozdělení, když jeden požadavek ze sta trvá dvacet sekund. Opakováním každé zprávy několikrát získáš použitelné rozdělení a čteš medián jako typické chování a P99 jako svůj běžný nejhorší scénář.

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

Hodnocení pomocí LLM (LLM-as-Judge)

Tyto tři metriky vynechávají vše, co nemá jednu správnou odpověď: vysvětlení reklamní politiky, přeformulování prodeje, omluvná zpráva. Pro tyto otevřené odpovědi použij model k vyhodnocení kvality. Soudce obdrží otázku a odpověď, aplikuje kritéria, která jsi napsal – přesnost, relevanci, profesionalitu – a vrátí strukturované skóre díky Pydantic output_type. Právě omezení formátu činí proces použitelným: získáš agregovatelné celé číslo, nikoliv komentář k opětovnému přečtení.

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

Pole reason si zaslouží tvou pozornost během recenzí: zde soudce vysvětluje, proč dal 3 z 5, a často jde o formulaci chyby, kterou se ti nepodařilo pojmenovat.

Strukturované testovací sady

Hodnocení, které není reprodukovatelné, je k ničemu. Uspořádej své testovací případy do stabilního formátu, kde každý záznam nese ID, kategorii, otázku, očekávanou odpověď, očekávané nástroje a kvalitativní kritéria. Kategorie zde odvede veškerou práci: celkové skóre 4,2 z 5 je klamně uklidňující, zatímco podrobné skóre odhalí, že kategorie „sklad“ klesá na 2,8, zatímco „cena“ průměr táhne nahoru.

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

Spusť toto hodnocení ve svém pipeline průběžné integrace stejně jako své unit testy a nastav práh, pod kterým je doručení zablokováno. Od té chvíle se každá změna – nový model, vyladěné instrukce, přidaný nástroj – porovnává s předchozí na stejných případech a diskuse přestává točit kolem dojmů.

Klíčové poznatky

  • Hodnoť přesnost, použití nástrojů, latenci a náklady
  • Hodnocení pomocí LLM (LLM-as-Judge) zvládá otevřené odpovědi
  • Vytvářej strukturované a reprodukovatelné testovací sady
  • Automatizuj evaluaci ve svém CI/CD pro detekci regresí
  • Systematicky porovnávej změny (model, instrukce, nástroje)