Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Uw fine-getuned model evalueren

Les 10 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom evaluatie essentieel is
  2. Een testset samenstellen
  3. Geautomatiseerde evaluatie
  4. Gespecialiseerde metrics
  5. Menselijke evaluatie
  6. Evaluatierapport
  7. Belangrijkste punten

Update 2 november 2026 — Beschikbaarheid van fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd afgebouwd: sinds 7 mei 2026 kunnen organisaties die dit nog nooit hebben gebruikt geen taken meer starten; sinds 2 juli moet u binnen de laatste 60 dagen een fine-getuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken lanceren. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.

Waarom evaluatie essentieel is

Een succesvolle fine-tuning meet u niet alleen aan de hand van het verlies (loss). De echte vraag is: is uw fine-getuned model daadwerkelijk beter dan het basismodel voor uw use case? Een net dalende curve bewijst alleen dat het model heeft geleerd uw voorbeelden te reproduceren; het zegt niets over het gedrag bij onbekende verzoeken. In deze les leert u een rigoureus evaluatieprotocol opzetten, waarbij u geautomatiseerde metrics, LLM-beoordeling en menselijke review combineert.

Een testset samenstellen

Uw testset moet gescheiden zijn van zowel uw trainings- als validatiedata. Het onderscheid is belangrijk: de validatieset monitort de training en beïnvloedt dus uw hyperparameterkeuzes, wat deze geleidelijk verontreinigt. De testset opent u daarentegen pas wanneer het model bevroren is. Deze vertegenwoordigt de reële situaties waarmee uw model in productie te maken krijgt, met dezelfde verhoudingen tussen eenvoudige en lastige cases. Een verdeling van 80/10/10 op een eerder geschudde corpus is een redelijk startpunt.

import json
import random

def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
    """Splits data into train/validation/test."""
    with open(file, "r") as f:
        examples = [json.loads(l) for l in f]

    random.shuffle(examples)
    n = len(examples)
    i1 = int(n * ratios[0])
    i2 = int(n * (ratios[0] + ratios[1]))

    datasets = {
        "train": examples[:i1],
        "validation": examples[i1:i2],
        "test": examples[i2:]
    }

    for name, data in datasets.items():
        with open(f"{name}.jsonl", "w") as f:
            for ex in data:
                f.write(json.dumps(ex, ensure_ascii=False) + "\n")
        print(f"{name}: {len(data)} examples")

    return datasets

prepare_datasets("all_data.jsonl")

Geautomatiseerde evaluatie

Evaluatie op basis van metrics

Het principe is eenvoudig: voor elk testvoorbeeld verwijdert u het bericht van de assistent — dat is het verwachte antwoord, dat het model niet mag zien — dient u de rest in, en houdt u de input, het referentieantwoord en het gegenereerde antwoord naast elkaar. Deze structuur met drie kolommen vormt de basis voor alles wat volgt; het gebruik ervan voor metric-berekening of kwalitatieve beoordeling is slechts een kwestie van downstream-verwerking.

from openai import OpenAI

client = OpenAI()

def evaluate_model(model: str, test_examples: list[dict]) -> dict:
    """Evaluates a model on a test set."""
    results = []

    for ex in test_examples:
        # Extract the question (without the expected answer)
        input_messages = [
            m for m in ex["messages"] if m["role"] != "assistant"
        ]
        expected_answer = next(
            m["content"] for m in ex["messages"] if m["role"] == "assistant"
        )

        # Get the model's response
        response = client.responses.create(
            model=model,
            input=input_messages
        )
        model_answer = response.output_text

        results.append({
            "input": input_messages[-1]["content"],
            "expected": expected_answer,
            "obtained": model_answer
        })

    return results

Evaluatie met LLM-as-a-Judge

Een krachtige techniek is het inzetten van een hoogwaardig model om de kwaliteit van antwoorden te beoordelen. Woord-voor-woord vergelijking met de referentie wordt onbruikbaar zodra meerdere formuleringen acceptabel zijn; een judge waardeert echter de inhoud. De kwaliteit van het oordeel hangt volledig af van de precisie van de prompt: vier criteria gescoord van 1 tot 5, een geforceerde JSON-uitvoer en een vrije tekstcommentaar die u later gebruikt om fouten te begrijpen. Voorzie gevallen waarin de uitvoer niet parsebaar is, in plaats van een uitzondering de campagne te laten onderbreken.

def evaluate_with_judge(results: list[dict]) -> list[dict]:
    """Uses gpt-5.6-sol as a judge to evaluate responses."""
    evaluations = []

    for r in results:
        judge_prompt = f"""Evaluate the quality of the obtained response compared to the expected response.

Question: {r['input']}

Expected response: {r['expected']}

Obtained response: {r['obtained']}

Criteria (rate each from 1 to 5):
1. Accuracy: Is the information correct?
2. Completeness: Are all important points covered?
3. Style: Is the tone and format appropriate?
4. Conciseness: Is the response an appropriate length?

Respond in JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""

        response = client.responses.create(
            model="gpt-5.6-sol",
            input=judge_prompt
        )

        try:
            evaluation = json.loads(response.output_text)
            evaluations.append(evaluation)
        except json.JSONDecodeError:
            evaluations.append({"error": "Response not parseable"})

    return evaluations

Gespecialiseerde metrics

De twee vorige benaderingen werken goed voor geschreven antwoorden. Zodra de uitvoer van uw model een vaste structuur heeft, worden directere maatstaven mogelijk en bespaart u de omweg via een judge.

Voor classificatie

Wanneer de verwachte uitvoer tot een gesloten set behoort — een ticketcategorie, een sentiment, een productcode — wordt exacte overeenkomst weer relevant. Normaliseer hoofdletters en spaties voordat u vergelijkt; anders telt “Urgent” versus “urgent” als een fout en vertekent dit uw percentage.

def classification_metrics(results: list[dict]) -> dict:
    """Calculates precision, recall, and F1 for a classification task."""
    correct = sum(
        1 for r in results
        if r["expected"].strip().lower() == r["obtained"].strip().lower()
    )
    total = len(results)
    precision = correct / total if total > 0 else 0

    print(f"Precision: {precision:.2%} ({correct}/{total})")
    return {"precision": precision, "correct": correct, "total": total}

Voor function calling

Function calling beoordeelt u op twee assen die u apart moet meten. Een model dat de juiste functie kiest maar de parameter verkeerd invult, faalt anders dan een model dat het volledig verkeerde hulpmiddel aanroept: het eerste probleem lost u op met extractievoorbeelden, het tweede met discriminatievoorbeelden. Een enkele globale score zou dit onderscheid maskeren en u blind laten werken.

def function_calling_metrics(results: list[dict]) -> dict:
    """Evaluates the quality of function calls."""
    stats = {"correct_function": 0, "correct_params": 0, "total": 0}

    for r in results:
        stats["total"] += 1
        if r.get("expected_function") == r.get("obtained_function"):
            stats["correct_function"] += 1
        if r.get("expected_params") == r.get("obtained_params"):
            stats["correct_params"] += 1

    print(f"Correct function: {stats['correct_function']}/{stats['total']}")
    print(f"Correct parameters: {stats['correct_params']}/{stats['total']}")
    return stats

Menselijke evaluatie

Geautomatiseerde evaluatie vangt niet alles op. Een licht neerbuigende toon, een zin die uw klanten niet bevalt, een technisch correct maar onbruikbaar antwoord: deze gebreken komen alleen onder menselijk oog aan het licht. Het protocol is rechttoe rechtaan. Neem twintig tot vijftig antwoorden willekeurig, nooit de cases die u al als problematisch heeft gemarkeerd, anders meet u alleen uw eigen selectiebias. Definieer vervolgens duidelijke, meetbare criteria en formaliseer deze in een gestandaardiseerd beoordelingsrubriek zodat twee reviewers hetzelfde beoordelen.

Laat ten slotte meerdere personen evalueren en bereken de overeenstemming tussen beoordelaars (inter-rater agreement). Sterke oneenigheid wijst niet per se op een slecht model: vaak onthult het dat uw rubriek nog ambigu is en verduidelijking behoeft voordat u conclusies kunt trekken.

Voorbeeld van een beoordelingsrubriek

Criterion 1 (Poor) 3 (Acceptable) 5 (Excellent)
Relevance Off-topic Partially relevant Perfectly targeted
Tone Inappropriate Acceptable but plain Perfectly aligned
Format Not followed Partially followed Perfectly followed

Evaluatierapport

Een laatste reflex scheidt een evaluatie van een beslissing: leg beide families van resultaten vast in één rapport, vergezeld van een expliciete aanbeveling. De drempel die u stelt — hier een menselijk gemiddelde van 4 om naar productie te gaan, 3 om iteraties op de data uit te voeren — moet u kiezen voordat u de campagne start. Achaf besloten, past deze zich altijd aan aan het resultaat dat u hoopte te krijgen.

def evaluation_report(auto_results: dict, human_results: dict):
    """Generates a combined evaluation report."""
    print("=" * 60)
    print("FINE-TUNED MODEL EVALUATION REPORT")
    print("=" * 60)

    print(f"\nAutomated metrics:")
    for k, v in auto_results.items():
        print(f"  {k}: {v}")

    print(f"\nHuman evaluation:")
    for k, v in human_results.items():
        print(f"  {k}: {v}")

    print(f"\nRecommendation:")
    average_score = sum(human_results.values()) / len(human_results)
    if average_score >= 4:
        print("  Model is ready for production")
    elif average_score >= 3:
        print("  Improvements needed—iterate on data")
    else:
        print("  Insufficient results—rethink your approach")

Belangrijkste punten

  • Houd altijd een onafhankelijke testset gescheiden (noch training, noch validatie)
  • Combineer geautomatiseerde en menselijke evaluatie
  • Evaluatie met LLM-as-a-judge is een goed compromis tussen beide
  • Definieer meetbare criteria voordat u begint
  • Een lage loss-score garandeert geen productiekwaliteit