Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Įvertinkite savo agentus: metrikos ir etalonai

Paskaita 22 iš 25 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Įvertinkite savo agentus: metrikos ir etalonai
  2. Kodėl vertinti?
  3. Pagrindinės metrikos
  4. LLM vertinimas (LLM-as-Judge)
  5. Struktūrizuoti testų rinkiniai
  6. Svarbiausi punktai

Įvertinkite savo agentus: metrikos ir etalonai

Agentas, veikiantis kūrimo aplinkoje, gali žlugti gamyboje. Sistemingas vertinimas yra vienintelis būdas užtikrinti kokybę prieš diegimą ir po jo. Šioje pamokoje sužinosi, kaip apibrėžti metrikas, kurti testų rinkinius ir automatizuoti vertinimą.

Kodėl vertinti?

Be formalaus vertinimo veiki aklai. Perfrazuoji instrukciją, nes vartotojas pasiskundė, tačiau niekas nepasako, ar agentas pagerėjo, ar tiesiog sugadinai tris kitus scenarijus. Abejoji tarp „Terra“ ir „Luna“ savo naudojimui – arba tarp dviejų to paties modelio samprotavimo lygių – ir be matavimų sprendimas remiasi nuojauta po penkių rankinių bandymų. Pakeiti įrankio schemą, agentas nustoja jį naudoti konkrečiu atveju ir niekas to nepastebi, kol neišauga bilietų skaičius. Vertinimo rinkinys kiekvieną iš šių situacijų paverčia palyginamu skaičiumi nuo vienos versijos iki kitos.

Pagrindinės metrikos

Tikslumas

Pirmasis klausimas yra pats tiesiausias: ar agentas pateikia teisingą atsakymą? Perleidži klausimų rinkinį, kurio atsakymus žinai, ir patikrini jų buvimą išvestyje. Didžiosiomis ir mažosiomis raidėmis nesiskiriantis požymių eilučių sutapimas sąmoningai yra grubus – jis toleruoja „Pro nešiojamojo kompiuterio kaina yra 1 299 € su mokesčiais“, kai griežtas lygybės tikrinimas nepavyktų, – tačiau to pakanka patikrinamiems faktams ir apskaičiuojama per 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"},
]

Teisingas įrankių naudojimas

Teisingas atsakymas, gautas atsitiktinai, išlieka problema. Agentas, kuris deklamuoja įsimintą kainą užuot užklausęs katalogo, šiandien išlaikys tikslumo testą, o rytoj pateiks pasenusį tarifą. Todėl antroji metrika žiūri ne į rezultatą, o į kelią: ar agentas iškviečia tinkamus įrankius su tinkamais argumentais? Skaitai kvietimus raw_responses, filtruodamas function_call išvestis, o palyginimui naudoji aibes, kad būtum abejingas tvarkai.

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"],
    },
]

Antrasis testavimo atvejis yra pats informatyviausias: klausimas reikalauja sujungti du įrankius, ir tai būtent tokia kompozicija, kurią aprašymo pakeitimas gali tyliai sugadinti.

Vėlavimas ir kaina

Galiausiai yra operacinis aspektas. Vidurkis nieko nepasako apie realią patirtį: vartotojus atbūdo pasiskirstymo uodega, kai vienas iš šimto užklausų trunka dvidešimt sekundžių. Kelis kartus pakartojus kiekvieną žinutę, gauni naudojamą pasiskirstymą ir skaitai medianą kaip tipinį elgesį, o P99 – kaip dažniausiai pasitaikantį blogiausią atvejį.

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 vertinimas (LLM-as-Judge)

Šios trys metrikos neapima nieko, kas neturi vieno teisingo atsakymo: grąžinimo politikos paaiškinimo, pardavimų perfrazavimo, atsiprašymo žinutės. Tokiems atviriems atsakymams kokybei įvertinti naudok modelį. Vertintojas gauna klausimą ir atsakymą, taiko tavo nustatytus kriterijus – tikslumą, aktualumą, profesionalumą – ir grąžina struktūrizuotą įvertį dėka Pydantic output_type. Būtent formato apribojimas daro procesą naudojamu: gauni agreguojamą sveikąjį skaičių, o ne komentarą, kurį reikėtų perskaityti iš naujo.

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

Laukas reason peržiūrų metu nusipelno tavo dėmesio: čia vertintojas paaiškina, kodėl skyrė 3 iš 5, ir tai dažnai yra trūkumo, kurio pats nesugebėjai įvardyti, formulavimas.

Struktūrizuoti testų rinkiniai

Neatkuriamas vertinimas yra nenaudingas. Organizuok savo testų atvejus stabiliu formatu, kuriame kiekvienas įrašas turėtų ID, kategoriją, klausimą, laukiamą atsakymą, laukiamus įrankius ir kokybinius kriterijus. Kategorija čia atlieka visą darbą: bendras 4,2 iš 5 balų įvertis klaidingai ramina, tuo tarpu detalus įvertis atskleidžia, kad „atsargų“ kategorija smunka iki 2,8, o „kainos“ pakelia vidurkį.

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

Paleisk šį vertinimą savo nuolatinės integracijos (CI) sistemoje taip pat, kaip ir vieneto testus, bei nustatyk ribą, žemiau kurios tiekimas blokuojamas. Nuo tol kiekvienas pakeitimas – naujas modelis, pakoreguotos instrukcijos, pridėtas įrankis – lyginamas su ankstesniu tais pačiais atvejais, o diskusijos nustoja suktis apie įspūdžius.

Svarbiausi punktai

  • Vertink tikslumą, įrankių naudojimą, vėlavimą ir kainą
  • LLM vertinimas (LLM-as-Judge) tvarko atvirus atsakymus
  • Kurk struktūrizuotus ir atkuriamus testų rinkinius
  • Automatizuok vertinimą savo CI/CD sistemoje, kad aptiktum regresijas
  • Sistemingai lygink pakeitimus (modelį, instrukcijas, įrankius)