Novērtē savus aģentus: metrikas un etaloni
Šajā lapā
Novērtē savus aģentus: metrikas un etaloni
Aģents, kas darbojas izstrādes vidē, var izgāzties ražošanā. Sistemātiska novērtēšana ir vienīgais veids, kā garantēt kvalitāti pirms un pēc izvietošanas. Šajā nodarbībā tu iemācīsies definēt metrikas, izveidot testu kopas un automatizēt novērtēšanu.
Kāpēc novērtēt?
Bez formālas novērtēšanas tu lido akli. Tu pārfrāzē instrukciju, jo lietotājs sūdzējies, taču nekas nepasaka, vai aģents ir uzlabojies vai vai tu vienkārši sabojāji trīs citus scenārijus. Tu šaubies starp Terra un Luna savam lietojumam — vai starp diviem spriešanas līmeņiem vienā un tajā pašā modelī — un bez mērījumiem lēmums balstās uz nojautu pēc pieciem manuāliem mēģinājumiem. Tu maini rīka shēmu, aģents konkrētā gadījumā to vairs neizsauc, un neviens to nepamana, līdz biļešu apjoms strauji pieaug. Novērtēšanas kopa pārvērš katru no šīm situācijām salīdzināmā skaitlī no vienas versijas uz nākamo.
Pamatmetrikas
Precizitāte
Pirmajā jautājumā viss ir vistiešākais: vai aģents sniedz pareizo atbildi? Tu atkārto jautājumu kopu, kur zini atbildi, un pārbaudi tās esamību izvades datos. Reģistrneatkarīga apakšvirknes saskaņošana ir apzināti rupja — tā pieļauj „Pro klēpjdatora cena ir 1299 € ar nodokli”, kur stingra vienādība izgāztos —, taču tā pietiek pārbaudāmiem faktiem un aprēķina rezultātu 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"},
]
Pareiza rīku izmantošana
Pareiza atbilde, kas iegūta nejauši, joprojām ir problēma. Aģents, kas recitē iemācītu cenu, nevis vaicā katalogam, šodien izturēs precizitātes testu, bet rīt sniegs novecojušu likmi. Tāpēc otrā metrika aplūko ceļu, nevis rezultātu: vai aģents izsauc pareizos rīkus ar pareizajiem argumentiem? Tu nolasī izsaukumus raw_responses, filtrējot function_call izvades, un salīdzināšanai izmanto kopas, lai paliktu vienaldzīgs pret secību.
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"],
},
]
Otrais testa gadījums ir visinstruktīvākais: jautājums prasa savienot divus rīkus, un tieši šādu kompozīciju apraksta izmaiņas var klusi sabojāt.
Latence un izmaksas
Visbeidzot, ir operacionālā dimensija. Vidējais rādītājs neko nepasaka par reālo pieredzi: lietotājus atbaida sadalījuma aste, kad viens pieprasījums no simta ilgst divdesmit sekundes. Atkārtojot katru ziņojumu vairākas reizes, tu iegūsti lietojamu sadalījumu un nolasi mediānu kā tipisku uzvedību, bet P99 kā savu parasto sliktāko scenāriju.
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 novērtēšana (LLM-as-Judge)
Šīs trīs metrikas neaptver neko tādu, kam nav vienas pareizas atbildes: atgriešanas politikas skaidrojumu, pārdošanas teksta pārfrāzējumu, atvainošanās ziņojumu. Šādām atvērtām atbildēm izmanto modeli kvalitātes novērtēšanai. Tiesnesis saņem jautājumu un atbildi, pielieto tavus rakstītos kritērijus — precizitāti, atbilstību, profesionalitāti — un atgriež strukturētu vērtējumu, pateicoties Pydantic output_type. Formāta ierobežojums ir tas, kas padara procesu lietojamu: tu iegūsti apkopojamu veselu skaitli, nevis komentāru, kas jāpārlasa.
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
Lauks reason ir pelnījis tavu uzmanību pārskatu laikā: tieši šeit tiesnesis paskaidro, kāpēc tas devis 3 no 5, un bieži vien tas ir trūkuma formulējums, kuru tu pats neesi spējis nosaukt.
Strukturētas testu kopas
Novērtējums, kas nav reproducējams, ir bezjēdzīgs. Sakārto savus testa gadījumus stabilā formātā, kur katrs ieraksts nes ID, kategoriju, jautājumu, paredzamo atbildi, paredzamos rīkus un kvalitatīvos kritērijus. Kategorija šeit paveic visu darbu: kopējais vērtējums 4,2 no 5 ir maldinoši nomierinošs, turpretī detalizēts vērtējums atklāj, ka kategorija „krājumi” sabrūk līdz 2,8, kamēr „cena” velk vidējo rādītāju uz augšu.
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
Palaid šo novērtējumu savā nepārtrauktās integrācijas (CI) cauruļvadā tāpat kā vienības testus un nosaki slieksni, zem kura piegāde tiek bloķēta. No šī brīža katra izmaiņa — jauns modelis, pielāgotas instrukcijas, pievienots rīks — tiek salīdzināta ar iepriekšējo tajos pašos gadījumos, un diskusijas vairs nerotē ap iespaidiem.
Galvenās atziņas
- Novērtē precizitāti, rīku izmantošanu, latenci un izmaksas
- LLM novērtēšana (LLM-as-Judge) apstrādā atvērtas atbildes
- Izveido strukturētas un reproducējamas testu kopas
- Automatizē novērtēšanu savā CI/CD, lai noteiktu regresijas
- Sistemātiski salīdzini izmaiņas (modelis, instrukcijas, rīki)