Įvertinkite savo agentus: metrikos ir etalonai
Šiame puslapyje
Įvertinkite savo agentus: metrikos ir etalonai
Agentas, veikiantis kūrimo aplinkoje, gali žlugti gamyboje. Sistemingas vertinimas yra vienintelis būdas užtikrinti kokybę prieš diegimą ir po jo. Šioje pamokoje sužinosi, kaip apibrėžti metrikas, kurti testų rinkinius ir automatizuoti vertinimą.
Kodėl vertinti?
Be formalaus vertinimo veiki aklai. Perfrazuoji instrukciją, nes vartotojas pasiskundė, tačiau niekas nepasako, ar agentas pagerėjo, ar tiesiog sugadinai tris kitus scenarijus. Abejoji tarp „Terra“ ir „Luna“ savo naudojimui – arba tarp dviejų to paties modelio samprotavimo lygių – ir be matavimų sprendimas remiasi nuojauta po penkių rankinių bandymų. Pakeiti įrankio schemą, agentas nustoja jį naudoti konkrečiu atveju ir niekas to nepastebi, kol neišauga bilietų skaičius. Vertinimo rinkinys kiekvieną iš šių situacijų paverčia palyginamu skaičiumi nuo vienos versijos iki kitos.
Pagrindinės metrikos
Tikslumas
Pirmasis klausimas yra pats tiesiausias: ar agentas pateikia teisingą atsakymą? Perleidži klausimų rinkinį, kurio atsakymus žinai, ir patikrini jų buvimą išvestyje. Didžiosiomis ir mažosiomis raidėmis nesiskiriantis požymių eilučių sutapimas sąmoningai yra grubus – jis toleruoja „Pro nešiojamojo kompiuterio kaina yra 1 299 € su mokesčiais“, kai griežtas lygybės tikrinimas nepavyktų, – tačiau to pakanka patikrinamiems faktams ir apskaičiuojama per sekundę.
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"},
]
Teisingas įrankių naudojimas
Teisingas atsakymas, gautas atsitiktinai, išlieka problema. Agentas, kuris deklamuoja įsimintą kainą užuot užklausęs katalogo, šiandien išlaikys tikslumo testą, o rytoj pateiks pasenusį tarifą. Todėl antroji metrika žiūri ne į rezultatą, o į kelią: ar agentas iškviečia tinkamus įrankius su tinkamais argumentais? Skaitai kvietimus raw_responses, filtruodamas function_call išvestis, o palyginimui naudoji aibes, kad būtum abejingas tvarkai.
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"],
},
]
Antrasis testavimo atvejis yra pats informatyviausias: klausimas reikalauja sujungti du įrankius, ir tai būtent tokia kompozicija, kurią aprašymo pakeitimas gali tyliai sugadinti.
Vėlavimas ir kaina
Galiausiai yra operacinis aspektas. Vidurkis nieko nepasako apie realią patirtį: vartotojus atbūdo pasiskirstymo uodega, kai vienas iš šimto užklausų trunka dvidešimt sekundžių. Kelis kartus pakartojus kiekvieną žinutę, gauni naudojamą pasiskirstymą ir skaitai medianą kaip tipinį elgesį, o P99 – kaip dažniausiai pasitaikantį blogiausią atvejį.
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 vertinimas (LLM-as-Judge)
Šios trys metrikos neapima nieko, kas neturi vieno teisingo atsakymo: grąžinimo politikos paaiškinimo, pardavimų perfrazavimo, atsiprašymo žinutės. Tokiems atviriems atsakymams kokybei įvertinti naudok modelį. Vertintojas gauna klausimą ir atsakymą, taiko tavo nustatytus kriterijus – tikslumą, aktualumą, profesionalumą – ir grąžina struktūrizuotą įvertį dėka Pydantic output_type. Būtent formato apribojimas daro procesą naudojamu: gauni agreguojamą sveikąjį skaičių, o ne komentarą, kurį reikėtų perskaityti iš naujo.
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
Laukas reason peržiūrų metu nusipelno tavo dėmesio: čia vertintojas paaiškina, kodėl skyrė 3 iš 5, ir tai dažnai yra trūkumo, kurio pats nesugebėjai įvardyti, formulavimas.
Struktūrizuoti testų rinkiniai
Neatkuriamas vertinimas yra nenaudingas. Organizuok savo testų atvejus stabiliu formatu, kuriame kiekvienas įrašas turėtų ID, kategoriją, klausimą, laukiamą atsakymą, laukiamus įrankius ir kokybinius kriterijus. Kategorija čia atlieka visą darbą: bendras 4,2 iš 5 balų įvertis klaidingai ramina, tuo tarpu detalus įvertis atskleidžia, kad „atsargų“ kategorija smunka iki 2,8, o „kainos“ pakelia vidurkį.
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
Paleisk šį vertinimą savo nuolatinės integracijos (CI) sistemoje taip pat, kaip ir vieneto testus, bei nustatyk ribą, žemiau kurios tiekimas blokuojamas. Nuo tol kiekvienas pakeitimas – naujas modelis, pakoreguotos instrukcijos, pridėtas įrankis – lyginamas su ankstesniu tais pačiais atvejais, o diskusijos nustoja suktis apie įspūdžius.
Svarbiausi punktai
- Vertink tikslumą, įrankių naudojimą, vėlavimą ir kainą
- LLM vertinimas (LLM-as-Judge) tvarko atvirus atsakymus
- Kurk struktūrizuotus ir atkuriamus testų rinkinius
- Automatizuok vertinimą savo CI/CD sistemoje, kad aptiktum regresijas
- Sistemingai lygink pakeitimus (modelį, instrukcijas, įrankius)