Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Hodnotenie vašich agentov: Metriky a benchmarky

Lekcia 22 z 25 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Hodnotenie vašich agentov: Metriky a benchmarky
  2. Prečo hodnotiť?
  3. Kľúčové metriky
  4. Hodnotenie pomocou LLM (LLM-as-Judge)
  5. Štruktúrované testovacie sady
  6. Kľúčové poznatky

Hodnotenie vašich agentov: Metriky a benchmarky

Agent, ktorý funguje vo vývojovom prostredí, môže v produkcii zlyhať. Systematické hodnotenie je jediným spôsobom, ako zaručiť kvalitu pred nasadením aj po ňom. V tejto lekcii sa naučíš definovať metriky, vytvárať testovacie sady a automatizovať hodnotenie.

Prečo hodnotiť?

Bez formálneho hodnotenia lietate naslepo. Preformuluješ inštrukciu, pretože sa používateľ sťažoval, ale nič ti nepovie, či sa agent zlepšil, alebo či si práve nerozbil tri iné scenáre. Váhaš medzi modelmi Terra a Luna pre svoj prípad použitia – alebo medzi dvoma úrovňami logického uvažovania na tom istom modeli – a bez merania sa rozhoduješ podľa pocitu po piatich manuálnych pokusoch. Zmeníš schému nástroja, agent ho v konkrétnom prípade prestane volať a nikto si to nevšimne, kým nevyšplhá počet tiketov. Hodnotiaca sada premení každú z týchto situácií na porovnateľné číslo z jednej verzie na druhú.

Kľúčové metriky

Presnosť

Prvá otázka je najpriamejšia: dáva agent správnu odpoveď? Prehráš sadu otázok, kde poznáš odpoveď, a overíš jej prítomnosť vo výstupe. Porovnávanie podreťazcov bez rozlišovania veľkosti písmen je zámerne hrubé – toleruje vetu „Notebook Pro stojí 1 299 € vrátane DPH“, kde by prísna rovnosť zlyhala – ale na overiteľné fakty stačí a výpočet trvá sekundu.

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"])
        # Automatická alebo LLM-based verifikácia
        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

# Testovacia sada
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ávne použitie nástrojov

Správna odpoveď získaná náhodou zostáva problémom. Agent, ktorý recituje zapamätanú cenu namiesto dotazu do katalógu, dnes prejde testom presnosti a zajtra vráti zastaranú sadzbu. Druhá metrika sa preto pozerá na cestu, nie na výsledok: volá agent správne nástroje so správnymi argumentmi? Čítaš volania v raw_responses, filtruješ výstupy function_call a porovnanie používa množiny, aby bolo ľahostajné voči poradiu.

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

        # Extrahovanie volaných nástrojov zo surových odpovedí
        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í prípad je najpoučnejší: otázka vyžaduje zreťazenie dvoch nástrojov a presne toto druh kompozície môže zmena v popise ticho rozbiť.

Latencia a náklady

Nakoniec tu je operačný rozmer. Priemer nič nehovorí o skutočnej skúsenosti: používateľov odrádza chvost rozdelenia, keď jedna požiadavka zo sto trvá dvadsať sekúnd. Opakovaním každej správy viackrát získaš použiteľné rozdelenie a čítaš medián ako typické správanie a P99 ako bežný najhorší scenár.

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

Hodnotenie pomocou LLM (LLM-as-Judge)

Tieto tri metriky vynechávajú všetko, čo nemá jednu správnu odpoveď: vysvetlenie podmienok vrátenia tovaru, prepis predajného textu, ospravedlnenie. Pre tieto otvorené odpovede použi model na hodnotenie kvality. Rozhodca (judge) dostane otázku a odpoveď, aplikuje tebou napísané kritériá – presnosť, relevantnosť, profesionalita – a vráti štruktúrované skóre vďaka Pydantic output_type. Obmedzenie formátu je to, čo robí proces použiteľným: dostaneš agregovateľné celé číslo, nie komentár na opätovné čítanie.

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

Poľu reason venuj počas revízií pozornosť: tu rozhodca vysvetľuje, prečo dal 3 z 5, a často ide o formuláciu chyby, ktorú sa ti doteraz nepodarilo pomenovať.

Štruktúrované testovacie sady

Hodnotenie, ktoré nie je reprodukovateľné, je zbytočné. Organizuj svoje testovacie prípady v stabilnom formáte, kde každý záznam nesie ID, kategóriu, otázku, očakávanú odpoveď, očakávané nástroje a kvalitatívne kritériá. Kategória tu robí všetku prácu: celkové skóre 4,2 z 5 je zavádzajúco upokojujúce, zatiaľ čo podrobné skóre odhalí, že kategória „stock“ sa prepadne na 2,8, zatiaľ čo „price“ ťahá priemer nahor.

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

    # Správa
    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

Spusti toto hodnotenie vo svojom pipeline priebežnej integrácie (CI), rovnako ako svoje unit testy, a nastav prah, pod ktorým je doručenie zablokované. Od tej chvíle sa každá zmena – nový model, upravené inštrukcie, pridaný nástroj – porovná s predchádzajúcou na tých istých prípadoch a diskusia sa prestane točiť okolo dojmov.

Kľúčové poznatky

  • Hodnoť presnosť, použitie nástrojov, latenciu a náklady
  • Hodnotenie pomocou LLM (LLM-as-Judge) rieši otvorené odpovede
  • Vytváraj štruktúrované a reprodukovateľné testovacie sady
  • Automatizuj hodnotenie v CI/CD na detekciu regresie
  • Systematicky porovnávaj zmeny (model, inštrukcie, nástroje)