Evaluatie die releases bewaakt

Eerst meten, dan verbeteren

Agents falen op manieren die demo's verbergen. Een demo toont vijf goede runs. Productie stuurt er vijfduizend, en de zestig die misgaan zijn de runs die je klant onthoudt. Een evaluatieset is hoe je die zestig vindt voor de klant dat doet.

Bij NexOps beginnen we een agentbouw niet met het model. We beginnen met een set echte cases en een definitie van "goed". Het model, de prompt en de tools zijn daarna variabelen die we veranderen en meten. In deze les bouwen we die meting: de set, de scorers, de controle van de judges en de regressiepoort.

Stap 1: bouw de evaluatieset uit echte cases

Een evaluatieset is een lijst invoer en bij veel items de verwachte uitkomst. Begin klein en echt.

• Verzamel 30 tot 50 echte taken van de mensen die het werk nu doen: tickets, verzoeken, documenten. Echte cases bevatten de rare formulering, het ontbrekende veld en de boze klant die verzonnen cases missen.
• Dek de randen af. Voeg cases toe waarin het juiste antwoord "dit kan ik niet" is, cases met ontbrekende data en cases die de agent van zijn taak proberen af te brengen.
• Schrijf verwachtingen. Schrijf per case wat een correct resultaat bevat: feiten die moeten voorkomen, tools die moeten worden aangeroepen, acties die niet mogen gebeuren.
• Houd een deel apart. Tune niet op alle cases. Houd een deel achter de hand om te controleren of je verbeteringen generaliseren.

Op Databricks staan MLflow-evaluatiedatasets in Unity Catalog en zijn ze gekoppeld aan een MLflow-experiment. Je hebt CREATE TABLE nodig op het doelschema. Je kunt records toevoegen uit vastgelegde traces of ze zelf schrijven.

import mlflow
import mlflow.genai.datasets
 
# Maak een dataset in Unity Catalog (naamformaat: catalog.schema.tabel).
eval_dataset = mlflow.genai.datasets.create_dataset(
    name="workspace.default.support_agent_eval",
)
 
# Voeg echte productietraces toe die zonder fout zijn afgerond.
traces = mlflow.search_traces(
    filter_string="attributes.status = 'OK' AND tags.environment = 'production'",
    max_results=10,
)
eval_dataset = eval_dataset.merge_records(traces)
 
# Voeg een gelabelde case toe met een bekende verwachte uitkomst.
# De docs gebruiken zowel "expected" als "expectations" als sleutel: controleer je MLflow-versie.
eval_dataset = eval_dataset.merge_records([
    {
        "inputs": {"question": "Where is order SO-100234?"},
        "expected": {"expected_facts": ["order status", "delivery date"]},
    },
])

De documentatie noemt limieten van 2.000 rijen per dataset en 20 verwachtingen per record, dus een gerichte set past sowieso beter dan een enorme.

Stap 2: kies scorers

Een scorer zet een trace om in een oordeel. Er zijn twee families.

MLflow levert ingebouwde judges zoals Safety, RetrievalGroundedness, Correctness (die verwachtingen nodig heeft), ToolCallCorrectness en ToolCallEfficiency. Ook is er Guidelines, dat een antwoord toetst aan criteria die je in gewone taal schrijft, plus eigen judges en codescorers in Python.

Kies waar mogelijk een regel boven een judge. Een regel heeft nooit een slechte dag.

Stap 3: controleer de judges tegen mensen

Een LLM-judge is een model, en modellen hebben het weleens mis. Meet voor je een judge vertrouwt hoe vaak hij het met een mens eens is.

1. Neem 30 cases en laat een domeinexpert elk label geven: geslaagd of gefaald.
2. Draai de judge op dezelfde cases.
3. Bereken de overeenstemming en lees elk verschil.

Is de overeenstemming laag, dan zijn de instructies van de judge onduidelijk of is het criterium te vaag om toe te passen. Herschrijf het criterium tot twee mensen en de judge het eens zijn. De Databricks-documentatie beschrijft het afstemmen van judges op menselijke feedback om de nauwkeurigheid voor jouw domein te verbeteren. Gebruik dat als hulpmiddel voor deze stap en houd daarnaast een steekproef menselijke review in bedrijf.

Stap 4: draai het en bewaak ermee

mlflow.genai.evaluate() draait je scorers over een dataset en legt de resultaten vast, zodat je versies kunt vergelijken.

# Schematisch: argumentnamen kunnen per MLflow-versie verschillen. Controleer de actuele docs.
import mlflow
from mlflow.genai.scorers import Safety, Guidelines
 
def predict(question: str) -> str:
    return my_agent.answer(question)   # jouw agent, één keer per case aangeroepen
 
results = mlflow.genai.evaluate(
    data=eval_dataset,
    predict_fn=predict,
    scorers=[
        Safety(),
        Guidelines(name="polite_and_short", guidelines="Reply in at most 120 words and stay polite."),
    ],
)

Zet het resultaat daarna om in een regressiepoort in je pipeline. Een poort is een regel die een release stopt:

• Het slagingspercentage op de evaluatieset mag niet dalen ten opzichte van de huidige productieversie.
• Geen enkele case in de veiligheidsgroep mag falen.
• De kosten per taak blijven binnen het budget (les 6).

Dezelfde scorers kunnen op een steekproef van het productieverkeer draaien, zodat de kwaliteit die je vóór de release mat ook erna gemeten blijft. Elke productiefout die je vindt, wordt een nieuwe case in de dataset. Zo wordt de set beter.

Veelgemaakte fouten

• Testen op de cases waarop je getuned hebt. Houd een deel apart.
• Eén totaalscore. Rapporteer per groep, zodat een veiligheidsfout zich niet achter een hoog gemiddelde verbergt.
• Een ongecontroleerde judge vertrouwen. Meet eerst de overeenstemming met mensen.
• Nooit cases toevoegen. Elk incident is een gratis testcase.

Samenvatting

Bouw de set uit echte cases, schrijf verwachtingen, kies regels boven judges, controleer de judges tegen mensen en bewaak elke release met het resultaat. Volgende les: guardrails en veiligheid, waar de evaluatieset zijn moeilijkste cases vandaan haalt.