Ügynökeid kiértékelése: Metrikák és benchmarkok
Ezen az oldalon
Ügynökeid kiértékelése: Metrikák és benchmarkok
Egy fejlesztői környezetben működő ügynök a éles rendszerben elbukhat. A szisztematikus kiértékelés az egyetlen módja annak, hogy a telepítés előtt és után is garantáld a minőséget. Ebben a leckében megtanulod, hogyan definiálj metrikákat, hozz létre tesztkészleteket, és automatizáld a kiértékelést.
Miért érdemes kiértékelni?
Formális kiértékelés nélkül vakrepülést végzel. Átfogalmazol egy utasítást, mert egy felhasználó panaszkodott, de semmi nem árulja el, hogy az ügynök tényleg javult-e, vagy csak elrontottál három másik forgatókönyvet. Hezitálsz, hogy a Terra vagy a Luna jobb-e az esetedben – vagy ugyanazon a modellen két különböző következtetési szint között –, és mérés nélkül a döntésed öt manuális próba utáni megérzésen alapul. Módosítasz egy eszköz sémáját, az ügynök egy adott esetben megszűnik meghívni azt, és senki nem veszi észre, amíg a jegyek száma meg nem ugrik. Egy kiértékelési készlet minden ilyen helyzetet összehasonlítható számmá alakít az egyik verzióról a másikra.
Alapvető metrikák
Pontosság
Az első kérdés a legközvetlenebb: az ügynök a helyes választ adja-e? Lejátszasz egy olyan kérdéssort, ahol ismered a választ, és ellenőrzöd annak jelenlétét a kimenetben. A kis- és nagybetűktől független részegyezés szándékosan durva – elnézi például, hogy „A Pro laptop ára 1299 euró, ÁFÁ-val“, ahol a szigorú egyenlőség megbukna –, de ellenőrizhető tényekhez elegendő, és másodpercek alatt kiszámolható.
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"])
# Automatikus vagy LLM-alapú ellenőrzés
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
# Tesztkészlet
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"},
]
Helyes eszközhasználat
A véletlenül megszerzett helyes válasz is probléma marad. Egy ügynök, amely bemagolt árat szaval a katalógus lekérdezése helyett, ma átmenő pontosságot produkál, holnap pedig elavult árat ad. A második metrika ezért nem az eredményt, hanem az utat vizsgálja: az ügynök a megfelelő eszközöket hívja meg a megfelelő argumentumokkal? Kiolvasod a hívásokat a raw_responses elemből, kiszűröd a function_call kimeneteket, és a comparison halmazokat használ, hogy független maradj a sorrendtől.
async def evaluate_tools(agent, test_cases):
results = []
for case in test_cases:
result = await Runner.run(agent, case["question"])
# Meghívott eszközök kinyerése a nyers válaszokból
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"],
},
]
A második teszteset a legtanulságosabb: a kérdés két eszköz láncolását igényli, és pontosan ez az a fajta összetétel, amelyet egy leírás módosítása csendben elronthat.
Késleltetés és költség
Végül ott van az operatív dimenzió. Egy átlag semmit nem mond a valós élményről: az eloszlás farokvége űzi el a felhasználókat, amikor száz kérésből egy húsz másodpercig tart. Minden üzenetet többször megismételve használható eloszlást kapsz, ahol a medián a tipikus viselkedést, a P99 pedig a gyakori legrosszabb esetet mutatja.
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-alapú kiértékelés (LLM-as-Judge)
Ez a három metrika kihagy mindent, aminek nincs egyetlen helyes válasza: egy visszaküldési szabályzat magyarázata, egy értékesítési szöveg átfogalmazása, egy bocsánatkérő üzenet. Ezekre a nyitott végű válaszokra használj egy modellt a minőség értékelésére. A bíró megkapja a kérdést és a választ, alkalmazza az általad írt kritériumokat – pontosság, relevancia, professzionalizmus –, majd egy strukturált pontszámot ad vissza egy Pydantic output_type segítségével. A formátumkényszer teszi használhatóvá a folyamatot: aggregálható egész számot kapsz, nem pedig újraolvasandó kommentárt.
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
A reason mező figyelmet érdemel az átvizsgálások során: itt magyarázza el a bíró, miért adott 3-at ötből, és ez gyakran egy olyan hiba megfogalmazása, amelyet korábban nem sikerült néven nevezned.
Strukturált tesztkészletek
Egy nem reprodukálható kiértékelés haszontalan. Szervezd a teszteseteidet stabil formátumba, ahol minden bejegyzés tartalmaz egy azonosítót, egy kategóriát, a kérdést, a várt választ, a várt eszközöket és a minőségi kritériumokat. Itt a kategória végzi a legtöbb munkát: egy 4,2-es átlagpontszám ötből megtévesztően megnyugtató, míg a részletes pontszám feltárja, hogy a „készlet“ kategória 2,8-ra omlik össze, miközben az „ár“ felfelé húzza az átlagot.
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,
})
# Jelentés
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
Futtasd ezt a kiértékelést a folyamatos integrációs (CI) folyamatodban, akárcsak az egységteszteket, és állíts be egy küszöbértéket, amely alatt a kézbesítés blokkolva van. Innentől kezdve minden változás – új modell, hangolt utasítások, hozzáadott eszköz – összehasonlítható az előzővel ugyanazon eseteken, és a vita többé nem az benyomások körül forog.
Főbb megállapítások
- Értékeld a pontosságot, az eszközhasználatot, a késleltetést és a költséget
- Az LLM-alapú kiértékelés (LLM-as-Judge) kezeli a nyitott végű válaszokat
- Hozz létre strukturált és reprodukálható tesztkészleteket
- Automatizáld a kiértékelést a CI/CD folyamatodban a regressziók észlelésére
- Hasonlítsd össze szisztematikusan a változásokat (modell, utasítások, eszközök)