Hodnocení vašich agentů: Metriky a benchmarky
Na této stránce
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)