Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Ocena vaših agentov: metrike in referenčne vrednosti

Lekcija 22 od 25 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Ocena vaših agentov: metrike in referenčne vrednosti
  2. Zakaj ocenjevati?
  3. Osnovne metrike
  4. Ocena z LLM (LLM-as-Judge)
  5. Strukturirani nabori testov
  6. Ključne ugotovitve

Ocena vaših agentov: metrike in referenčne vrednosti

Agent, ki deluje v razvojnem okolju, lahko v proizvodnji odpove. Sistematična ocena je edini način, da zagotovite kakovost pred in po uvedbi. V tej lekciji se boste naučili definirati metrike, ustvariti teste in avtomatizirati ocenjevanje.

Zakaj ocenjevati?

Brez formalne ocene letite na slepo. Ponovno oblikujete navodilo, ker se je uporabnik pritožil, vendar nič ne pove, ali se je agent izboljšal ali ste ravno pokvarili tri druge scenarije. Oklevate med Terrao in Luno za svoj primer uporabe – ali med dvema ravnema sklepanja na istem modelu – in brez meritev temelji odločitev na občutku po petih ročnih poskusih. Spremenite shemo orodja, agent ga v določenem primeru preneha klicati in nihče tega ne opazi, dokler se število vstopnic ne poveča. Nabor testov vsak od teh primerov spremeni v primerljivo številko od ene različice do naslednje.

Osnovne metrike

Točnost

Prvo vprašanje je najbolj neposredno: ali agent poda pravilen odgovor? Ponovite niz vprašanj, kjer poznate odgovor, in preverite njegovo prisotnost v izhodu. Primerjava podnizov, ki ne upošteva velikosti črk, je namerno groba – dopušča „Prenosni računalnik Pro stane 1.299 € z DDV”, kjer bi strogo enakost odpovedala – vendar zadostuje za preverljiva dejstva in se izračuna v sekundi.

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"])
        # Samodejno preverjanje ali preverjanje z LLM
        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"Točnost: {rate:.1%} ({sum(1 for r in results if r['correct'])}/{len(results)})")
    return results

# Nabor testov
test_cases = [
    {"question": "Kolikšna je cena prenosnega računalnika Pro?", "expected_answer": "1299"},
    {"question": "Koliko prenosnih računalnikov je na zalogi?", "expected_answer": "45"},
    {"question": "Kateri izdelek je najcenejši?", "expected_answer": "tablica"},
]

Pravilna uporaba orodij

Pravilen odgovor, dobljen po naključju, ostaja težava. Agent, ki recitira zapomnjeno ceno namesto poizvedbe v katalogu, bo danes opravil test točnosti, jutri pa bo podal zastarelo stopnjo. Druga metrika zato gleda na pot, ne na rezultat: ali agent kliče prava orodja s pravilnimi argumenti? Preberete klice v raw_responses, filtrirate izhode function_call, primerjava pa uporablja množice, da ostane neodvisna od vrstnega reda.

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

        # Izloči poklicana orodja iz surovih odgovorov
        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"Pravilna orodja: {rate:.1%}")
    return results

tool_cases = [
    {
        "question": "Kolikšna je cena prenosnega računalnika?",
        "expected_tools": ["search_product"],
    },
    {
        "question": "Cena prenosnega računalnika z 10-odstotnim popustom",
        "expected_tools": ["search_product", "calculate_discount"],
    },
]

Drugi testni primer je najbolj poučen: vprašanje zahteva veriženje dveh orodij in prav takšna kompozicija je tista, ki jo lahko sprememba v opisu tiho pokvari.

Latenca in stroški

Nazadnje je tu še operativna razsežnost. Povprečje ne pove ničesar o dejanski izkušnji: uporabnike odvrne rep porazdelitve, ko ena zahteva od sto traja dvajset sekund. Z večkratnim ponavljanjem vsakega sporočila dobite uporabno porazdelitev in berete mediano kot tipično obnašanje ter P99 kot svoj običajni najslabši primer.

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"Povprečna latenca: {statistics.mean(latencies):.2f}s")
    print(f"P50 latenca: {statistics.median(latencies):.2f}s")
    print(f"P99 latenca: {sorted(latencies)[int(len(latencies) * 0.99)]:.2f}s")

Ocena z LLM (LLM-as-Judge)

Te tri metrike izpuščajo vse, kar nima enega samega pravilnega odgovora: razlago politike vračila, preoblikovanje prodajnega besedila, sporočilo opravičila. Za te odprte odgovore uporabite model za oceno kakovosti. Sodnik prejme vprašanje in odgovor, uporabi merila, ki ste jih zapisali – točnost, ustreznost, profesionalnost – in vrne strukturirano oceno zahvaljujoč Pydantic output_type. Omejitev oblike je tisto, kar postopek naredi uporaben: dobite seštevljivo celo število, ne komentarja za ponovno branje.

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="""Ocenite kakovost odgovora agenta.
    Merila:
    - Točnost: Ali je odgovor dejanski in pravilen?
    - Ustreznost: Ali odgovor odgovarja na zastavljeno vprašanje?
    - Profesionalnost: Ali je ton ustrezen?
    Ocena od 1 (zelo slabo) do 5 (odlično).""",
    model="gpt-5.6-sol",
    output_type=Evaluation,
)

async def evaluate_quality(question, agent_response):
    prompt = f"""Zastavljeno vprašanje: {question}
    Odgovor agenta: {agent_response}
    Ocenite ta odgovor."""

    result = await Runner.run(evaluator_agent, prompt)
    return result.final_output

Polje reason si zasluži vašo pozornost med pregledi: tukaj sodnik razloži, zakaj je dal 3 od 5, in pogosto gre za formulacijo napake, ki je niste uspeli poimenovati.

Strukturirani nabori testov

Ocena, ki ni ponovljiva, je neuporabna. Organizirajte svoje testne primere v stabilni obliki, kjer vsak vnos nosi ID, kategorijo, vprašanje, pričakovani odgovor, pričakovana orodja in kvalitativna merila. Kategorija tu opravi vse delo: skupna ocena 4,2 od 5 je zavajajoče pomirjujoča, medtem ko podrobna ocena razkrije, da kategorija „zaloga” pade na 2,8, medtem ko „cena” povleče povprečje navzgor.

import json

# evaluation_dataset.json
DATASET = [
    {
        "id": "test_001",
        "category": "price",
        "question": "Kolikšna je cena prenosnega računalnika Pro?",
        "expected_answer": "1.299 €",
        "expected_tools": ["search_product"],
        "criteria": ["contains_price", "professional_tone"],
    },
    {
        "id": "test_002",
        "category": "stock",
        "question": "Ali je tablica Air na zalogi?",
        "expected_answer": "da",
        "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,
        })

    # Poročilo
    average_score = sum(r["score"] for r in results) / len(results)
    print(f"\nPovprečna ocena: {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

To oceno zaženite v svojem cevovodu za neprekinjeno integracijo, tako kot svoje enotske teste, in nastavite prag, pod katerim je dostava blokirana. Od takrat naprej se vsaka sprememba – nov model, prilagojena navodila, dodano orodje – primerja s prejšnjo na istih primerih in razprava preneha krožiti okoli vtisov.

Ključne ugotovitve

  • Ocenjujte točnost, uporabo orodij, latenco in stroške
  • Ocena z LLM (LLM-as-Judge) obravnava odprte odgovore
  • Ustvarite strukturirane in ponovljive nabore testov
  • Avtomatizirajte ocenjevanje v svojem CI/CD za odkrivanje regresij
  • Sistematično primerjajte spremembe (model, navodila, orodja)