Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Utvärdera dina agenter: Mätetal och referensvärden

Lektion 22 av 25 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Utvärdera dina agenter: Mätetal och referensvärden
  2. Varför utvärdera?
  3. Kärnmetriker
  4. LLM-utvärdering (LLM-as-Judge)
  5. Strukturerade testsviter
  6. Viktiga punkter

Utvärdera dina agenter: Mätetal och referensvärden

En agent som fungerar i utvecklingsmiljön kan misslyckas i produktion. Systematisk utvärdering är det enda sättet att garantera kvalitet både före och efter lansering. I den här lektionen lär du dig hur du definierar mätetal, skapar testsviter och automatiserar utvärderingen.

Varför utvärdera?

Utan formell utvärdering flyger du blindt. Du formulerar om en instruktion eftersom en användare klagade, men ingenting berättar för dig om agenten faktiskt blev bättre eller om du bara förstörde tre andra scenarier. Du tvekar mellan Terra och Luna för ditt användningsfall – eller mellan två resonemangsnivåer på samma modell – och utan mätningar vilar beslutet på en magkänsla efter fem manuella försök. Du ändrar ett verktygsschema, agenten slutar anropa det i ett specifikt fall, och ingen märker det förrän antalet supportärenden skenar. En utvärderingssvit omvandlar var och en av dessa situationer till ett jämförbart tal från en version till nästa.

Kärnmetriker

Noggrannhet

Den första frågan är den mest direkta: ger agenten rätt svar? Du spelar upp en uppsättning frågor där du känner till svaret och verifierar att det finns med i utdata. Skiftlägesokänslig delsträngsmatchning är avsiktligt grov – den tolererar “Pro-bärbara datorn kostar 1 299 € inkl. moms” där strikt likhet skulle misslyckas – men det räcker för verifierbara fakta och beräkningen tar en 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"])
        # Automatisk eller LLM-baserad verifiering
        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

# Testsvit
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 verktygsanvändning

Ett korrekt svar som erhållits av misstag är fortfarande ett problem. En agent som rabblar ett inmemorerat pris istället för att fråga katalogen kommer att klara noggrannhetstestet idag men ge ett föråldrat pris imorgon. Den andra metriken tittar därför på vägen, inte resultatet: anropar agenten rätt verktyg med rätt argument? Du läser anropen i raw_responses, filtrerar efter function_call-utdata, och jämförelsen använder mängder (sets) för att vara oberoende av ordning.

async def evaluate_tools(agent, test_cases):
    results = []
    for case in test_cases:
        result = await Runner.run(agent, case["question"])

        # Extrahera anropade verktyg från råa svar
        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 andra testfallet är det mest lärorika: frågan kräver kedjning av två verktyg, och detta är exakt den typ av komposition som en ändring i beskrivningen tyst kan bryta sönder.

Latens och kostnad

Slutligen finns den operativa dimensionen. Ett genomsnitt säger ingenting om den verkliga upplevelsen: det är svansen av fördelningen som skrämmer bort användare, när en förfrågan av hundra tar tjugo sekunder. Genom att upprepa varje meddelande flera gånger får du fram en användbar fördelning och kan läsa av medianen som det typiska beteendet, och P99 som ditt vanliga värsta scenario.

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-utvärdering (LLM-as-Judge)

Dessa tre metriker lämnar allt som inte har ett enda korrekt svar utanför: en förklaring av en returpolicy, en omformulering av ett säljmeddelande, ett ursäktsmeddelande. För dessa öppna svar använder du en modell för att utvärdera kvaliteten. Domaren får frågan och svaret, tillämpar kriterier du har skrivit – noggrannhet, relevans, professionalitet – och returnerar en strukturerad poäng tack vare en Pydantic output_type. Formatbegränsningen är det som gör processen användbar: du får ett heltal som går att aggregera, inte en kommentar som måste läsas om.

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

Fältet reason förtjänar din uppmärksamhet under granskningar: det är här domaren förklarar varför den gav 3 av 5, och det är ofta formuleringen av en brist du inte hade lyckats namnge.

Strukturerade testsviter

En utvärdering som inte är reproducerbar är värdelös. Organisera dina testfall i ett stabilt format där varje post har ett ID, en kategori, frågan, det förväntade svaret, de förväntade verktygen och kvalitativa kriterier. Kategorin gör hela jobbet här: ett totalt betyg på 4,2 av 5 är vilseledande lugnande, medan ett detaljerat betyg avslöjar att kategorin “lager” kollapsar till 2,8 medan “pris” drar upp genomsnittet.

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,
        })

    # Rapport
    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 denna utvärdering i din pipeline för kontinuerlig integration, precis som dina enhetstester, och sätt en tröskel under vilken leverans blockeras. Från och med då jämförs varje ändring – ny modell, justerade instruktioner, tillagt verktyg – med den föregående på samma fall, och diskussionen slutar kretsa kring intryck.

Viktiga punkter

  • Utvärdera noggrannhet, verktygsanvändning, latens och kostnad
  • LLM-utvärdering (LLM-as-Judge) hanterar öppna svar
  • Skapa strukturerade och reproducerbara testsviter
  • Automatisera utvärderingen i din CI/CD för att upptäcka regressioner
  • Jämför ändringar systematiskt (modell, instruktioner, verktyg)