Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Hinda oma agente: mõõdikud ja võrdlusalused

Õppetund 22 / 25 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Hinda oma agente: mõõdikud ja võrdlusalused
  2. Miks hinnata?
  3. Põhilised mõõdikud
  4. LLM-hindamine (LLM kui kohtunik)
  5. Struktureeritud testikomplektid
  6. Peamised punktid

Hinda oma agente: mõõdikud ja võrdlusalused

Agent, mis töötab arenduskeskkonnas, võib tootmises läbi kukkuda. Süstemaatiline hindamine on ainus viis tagada kvaliteet nii enne kui ka pärast kasutuselevõttu. Selles õppetükis õpid määratlema mõõdikuid, looma testikomplekte ja automatiseerima hindamisprotsessi.

Miks hinnata?

Ilma formaalse hindamiseta lendad pimesi. Sa sõnastad juhise ümber, sest kasutaja kaebas, kuid miski ei ütle sulle, kas agent paranes või rikkusid sa lihtsalt kolm muud stsenaariumi. Kahtled Terra ja Luna vahel oma kasutusjuhu jaoks – või kahe sama mudeli põhjendustaseme vahel – ja ilma mõõtmiseta põhineb otsus kõhutundel pärast viit manuaalset katsetust. Muudad tööriista skeemi, agent lõpetab selle kindlal juhul kutsumise ja keegi ei märka seda enne, kui piletite maht plahvatab. Hindamiskomplekt muudab iga sellise olukorra võrreldavaks numbriks ühest versioonist teise liikudes.

Põhilised mõõdikud

Täpsus

Esimene küsimus on kõige otsesem: kas agent annab õige vastuse? Taasesitad küsimuste komplekti, mille vastuseid sa tead, ja kontrollid nende olemasolu väljundis. Tõstutundetu alamstringi sobitamine on tahtlikult kare – see talub lauset „Pro sülearvuti maksab 1299 € koos käibemaksuga“, kus range võrdsus ebaõnnestuks – kuid see sobib kontrollitavate faktide jaoks ja arvutatakse sekundiga.

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"])
        # Automaatne või LLM-põhine kontroll
        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"Täpsus: {rate:.1%} ({sum(1 for r in results if r['correct'])}/{len(results)})")
    return results

# Testikomplekt
test_cases = [
    {"question": "Mis on Pro sülearvuti hind?", "expected_answer": "1299"},
    {"question": "Mitu sülearvutit on laos?", "expected_answer": "45"},
    {"question": "Mis on odavaim toode?", "expected_answer": "tahvelarvuti"},
]

Õige tööriistade kasutamine

Juhuslikult saadud õige vastus on endiselt probleem. Agent, mis loeb pähe õpitud hinda kataloogi pärimise asemel, läbib täpsustesti täna, kuid annab homme aegunud hinna. Teine mõõdik vaatab seega teekonda, mitte tulemust: kas agent kutsub õigeid tööriistu õigete argumentidega? Loed väljakutseid raw_responsesist, filtreerides function_call väljundeid, ja võrdlus kasutab hulki, et jääda järjekorra suhtes ükskõikseks.

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

        # Ekstraheeri kutsutud tööriistad toorestest vastustest
        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"Õiged tööriistad: {rate:.1%}")
    return results

tool_cases = [
    {
        "question": "Mis on sülearvuti hind?",
        "expected_tools": ["search_product"],
    },
    {
        "question": "Sülearvuti hind 10% soodustusega",
        "expected_tools": ["search_product", "calculate_discount"],
    },
]

Teine testjuhtum on kõige õpetlikum: küsimus nõuab kahe tööriista aheldamist ja just sellist kompositsiooni võib kirjelduse muutmine vaikselt rikkuda.

Latentsus ja kulud

Lõpuks on olemas operatiivne mõõde. Keskmine ei ütle tegeliku kogemuse kohta midagi: kasutajad peletab ära jaotuse saba, kui üks päring sajast võtab kakskümmend sekundit. Korrates iga sõnumit mitu korda, saad kasutatava jaotuse ja loed mediaani kui tüüpilist käitumist ning P99 kui oma levinumat halvimat stsenaariumi.

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

LLM-hindamine (LLM kui kohtunik)

Need kolm mõõdikut jätavad välja kõik, millel pole ühte õiget vastust: tagastuspoliitika selgitus, müügiteksti ümbersõnastus, vabanduskiri. Selliste avatud vastuste jaoks kasuta mudelit kvaliteedi hindamiseks. Kohtunik saab küsimuse ja vastuse, rakendab sinu kirjutatud kriteeriume – täpsus, asjakohasus, professionaalsus – ja tagastab struktureeritud hinde tänu Pydantic output_type-ile. Formaadi piirang on see, mis teeb protsessi kasutatavaks: saad liidetava täisarvu, mitte ümberlugemist vajava kommentaari.

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="""Hinda agendi vastuse kvaliteeti.
    Kriteeriumid:
    - Täpsus: Kas vastus on faktiline ja õige?
    - Asjakohasus: Kas vastus vastab esitatud küsimusele?
    - Professionaalsus: Kas toon on sobiv?
    Hinda skaalal 1 (väga halb) kuni 5 ( suurepärane).""",
    model="gpt-5.6-sol",
    output_type=Evaluation,
)

async def evaluate_quality(question, agent_response):
    prompt = f"""Esitatud küsimus: {question}
    Agendi vastus: {agent_response}
    Hinda seda vastust."""

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

Väli reason väärib ülevaatuste ajal tähelepanu: siin selgitab kohtunik, miks ta andis 3 viiest, ja see on sageli puuduse sõnastus, mida sa pole suutnud nimetada.

Struktureeritud testikomplektid

Hindamine, mida ei saa reprodutseerida, on kasutu. Korralda oma testjuhtumid stabiilses formaadis, kus iga kirje kannab ID-d, kategooriat, küsimust, oodatavat vastust, oodatavaid tööriistu ja kvalitatiivseid kriteeriume. Kategooria teeb siin kogu töö: üldine hinne 4,2 viiest on eksitavalt rahustav, samas kui detailne hinne paljastab, et „laoseisu“ kategooria kukub 2,8-ni, samal ajal kui „hind“ tõstab keskmist üles.

import json

# evaluation_dataset.json
DATASET = [
    {
        "id": "test_001",
        "category": "price",
        "question": "Mis on Pro sülearvuti hind?",
        "expected_answer": "1299 €",
        "expected_tools": ["search_product"],
        "criteria": ["contains_price", "professional_tone"],
    },
    {
        "id": "test_002",
        "category": "stock",
        "question": "Kas Tablet Air on laos?",
        "expected_answer": "jah",
        "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,
        })

    # Aruanne
    average_score = sum(r["score"] for r in results) / len(results)
    print(f"\nKeskmine hinne: {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äivita see hindamine oma pideva integratsiooni (CI) torustikus, täpselt nagu oma ühiktestid, ja määra lävi, millest allpool tarnimine blokeeritakse. Alates sellest hetkest võrdleb iga muutus – uus mudel, häälestatud juhised, lisatud tööriist – eelmist samadel juhtumitel ja arutelu lakkab tiirlemast muljete ümber.

Peamised punktid

  • Hinda täpsust, tööriistade kasutamist, latentsust ja kulusid
  • LLM-hindamine (LLM kui kohtunik) käsitleb avatud vastuseid
  • Loo struktureeritud ja reprodutseeritavad testikomplektid
  • Automatiseeri hindamine oma CI/CD-s taandumiste tuvastamiseks
  • Võrdle süstemaatiliselt muutusi (mudel, juhised, tööriistad)