Evaluér dine agenter: Metrikker og benchmarks
På denne side
Evaluér dine agenter: Metrikker og benchmarks
En agent, der fungerer i udviklingsmiljøet, kan fejle i produktionen. Systematisk evaluering er den eneste måde at garantere kvalitet før og efter udrulning. I denne lektion lærer du at definere metrikker, oprette testsuites og automatisere evalueringen.
Hvorfor evaluere?
Uden formel evaluering flyver du blindt. Du omskriver en instruktion, fordi en bruger har klaget, men intet fortæller dig, om agenten faktisk er blevet bedre, eller om du blot har ødelagt tre andre scenarier. Du tøver mellem Terra og Luna til dit use case – eller mellem to ræsonnementsniveauer på samme model – og uden målinger hviler beslutningen på en mavefornemmelse efter fem manuelle forsøg. Du ændrer et tool-skema, agenten holder op med at kalde det i et specifikt tilfælde, og ingen opdager det, før antallet af supportbilletter eksploderer. En evalueringssuite omdanner hver af disse situationer til et sammenligneligt tal fra den ene version til den næste.
Kernemetrikker
Nøjagtighed
Det første spørgsmål er det mest direkte: Giver agenten det rigtige svar? Du afspiller et sæt spørgsmål, hvor du kender svaret, og verificerer dets tilstedeværelse i outputtet. Case-insensitive substring-matching er bevidst groft – det tolererer „The Pro laptop costs €1,299 incl. tax”, hvor streng lighed ville fejle – men det er tilstrækkeligt til verificerbare fakta og beregnes på et 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"},
]
Korrekt tool-brug
Et korrekt svar, der opnås ved et tilfælde, forbliver et problem. En agent, der reciterer en udenadslært pris i stedet for at spørge kataloget, vil bestå nøjagtighedstesten i dag og give en forældet sats i morgen. Den anden metrik ser derfor på vejen, ikke resultatet: Kalder agenten de rigtige tools med de rigtige argumenter? Du læser kaldene i raw_responses, filtrerer efter function_call-outputs, og sammenligningen bruger sæt (sets) for at være ligeglad med rækkefølgen.
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"],
},
]
Det andet testtilfælde er det mest lærerige: Spørgsmålet kræver kædning af to tools, og det er præcis den type komposition, som en ændring i beskrivelsen kan ødelægge ubemærket.
Latens og omkostninger
Endelig er der den operationelle dimension. Et gennemsnit siger intet om den reelle oplevelse: Det er halen af fordelingen, der skræmmer brugerne væk, når én forespørgsel ud af hundrede tager tyve sekunder. Ved at gentage hver besked flere gange får du en brugbar fordeling og kan aflæse medianen som den typiske adfærd og P99 som dit almindelige worst-case-scenarie.
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-evaluering (LLM-as-Judge)
Disse tre metrikker udelader alt, der ikke har ét enkelt korrekt svar: En forklaring på en returpolitik, en omskrivning af et salgsargument, en undskyldningsbesked. Til disse åbne svar bruger du en model til at evaluere kvaliteten. Dommeren modtager spørgsmålet og svaret, anvender kriterier, du har skrevet – nøjagtighed, relevans, professionalisme – og returnerer en struktureret score takket være en Pydantic output_type. Formatbegrænsningen er det, der gør processen brugbar: Du får et tal, der kan aggregeres, ikke en kommentar, du skal genlæse.
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
Feltet reason fortjener din opmærksomhed under reviews: Her forklarer dommeren, hvorfor den gav 3 ud af 5, og det er ofte formuleringen af en fejl, du ikke selv havde formået at navngive.
Strukturerede testsuites
En evaluering, der ikke er reproducerbar, er ubrugelig. Organisér dine testtilfælde i et stabilt format, hvor hver post bærer et ID, en kategori, spørgsmålet, det forventede svar, de forventede tools og kvalitative kriterier. Kategorien gør alt arbejdet her: En samlet score på 4,2 ud af 5 er vildledende beroligende, hvorimod en detaljeret score afslører, at kategorien „lager” kollapser til 2,8, mens „pris” trækker gennemsnittet op.
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
Kør denne evaluering i din CI/CD-pipeline, ligesom dine unit-tests, og sæt en tærskel, under hvilken leverancen blokeres. Fra det øjeblik sammenlignes hver ændring – ny model, justerede instrukser, nyt tool – med den foregående version på de samme tilfælde, og diskussionen holder op med at kredse om impressioner.
Vigtige pointer
- Evaluér nøjagtighed, tool-brug, latens og omkostninger
- LLM-evaluering (LLM-as-Judge) håndterer åbne svar
- Opret strukturerede og reproducerbare testsuites
- Automatisér evalueringen i din CI/CD for at opdage regressioner
- Sammenlign systematisk ændringer (model, instrukser, tools)