Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Evaluér dine agenter: Metrikker og benchmarks

Lektion 22 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Evaluér dine agenter: Metrikker og benchmarks
  2. Hvorfor evaluere?
  3. Kernemetrikker
  4. LLM-evaluering (LLM-as-Judge)
  5. Strukturerede testsuites
  6. Vigtige pointer

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)