Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Evaluér din finjusterede model

Lektion 10 af 16 Opdateret 2. november 2026 Avanceret
På denne side
  1. Hvorfor evaluering er afgørende
  2. Opbygning af et testsæt
  3. Automatiseret evaluering
  4. Specialiserede metrikker
  5. Menneskelig evaluering
  6. Evalueringsrapport
  7. Vigtige pointer

Opdatering 2. november 2026 — Tilgængelighed af finjustering. OpenAIs selvbetjente finjustering udfases: Siden 7. maj 2026 har organisationer, der aldrig har brugt tjenesten, ikke længere kunnet oprette jobs; siden 2. juli skal du have brugt en finjusteret model inden for de sidste 60 dage; og fra 6. januar 2027 vil ingen kunde kunne starte nye jobs. Allerede trænede modeller forbliver brugbare, indtil deres basismodel udgår. Dette kursus er stadig nyttigt til at forstå og udnytte en eksisterende model; til nye projekter bør du prioritere prompt engineering, RAG og evalueringer.

Hvorfor evaluering er afgørende

En vellykket finjustering måles ikke kun på tab (loss). Det virkelige spørgsmål er: Er din finjusterede model faktisk bedre end basismodellen til dit brugstilfælde? En pænt faldende kurve beviser kun, at modellen har lært at reproducere dine eksempler; den siger intet om dens adfærd på ubesvarede forespørgsler. Denne lektion viser dig, hvordan du opbygger en rigorøs evalueringsprotokol, der kombinerer automatiserede metrikker, LLM-bedømmelse og menneskelig gennemgang.

Opbygning af et testsæt

Dit testsæt skal være adskilt fra både dine trænings- og valideringsdata. Distinktionen er vigtig: Valideringssættet overvåger træningen og påvirker derfor dine hyperparameterbeslutninger, hvilket gradvist forurener det. Testsættet åbnes derimod først, når modellen er frosset. Det repræsenterer de virkelige situationer, din model vil møde i produktion, med de samme proportioner af simple og tricky tilfælde. En 80/10/10-opdeling af et tidligere blandet korpus er et rimeligt udgangspunkt.

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")

Automatiseret evaluering

Metrikbaseret evaluering

Princippet er simpelt: For hvert testeksempel fjerner du assistant-beskeden – det er det forventede svar, som modellen ikke må se – indsender resten og beholder input, referencesvar og genereret svar side om side. Denne tre-kolonne struktur er fundamentet for alt, hvad der følger; at bruge den til metrikberegning eller kvalitativ bedømmelse er blot et spørgsmål om efterfølgende behandling.

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

LLM-as-a-Judge-evaluering

En kraftfuld teknik er at bruge en højtydende model til at bedømme svarkvaliteten. Ord-for-ord-sammenligning med referencen bliver ubrugelig, så snart flere formuleringer er acceptable; en dommer værdsætter derimod substansen. Kvaliteten af dens dom afhænger helt af præcisionen i prompten: fire kriterier vurderet fra 1 til 5, et tvunget JSON-output og en frittekstkommentar, du senere bruger til at forstå fejl. Planlæg for tilfælde, hvor outputtet ikke kan parses, i stedet for at lade en undtagelse afbryde kampagnen.

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

Specialiserede metrikker

De to tidligere tilgange fungerer godt til skriftlige svar. Så snart din models output har en fast struktur, bliver mere direkte målinger mulige og sparer dig for omvejen via en dommer.

Til klassificering

Når det forventede output tilhører et lukket sæt – en billetkategori, en stemning, en produktkode – bliver nøjagtig match (exact match) igen relevant. Normaliser store/små bogstaver og mellemrum før sammenligning; ellers vil „Urgent” kontra „urgent” tælle som en fejl og skævvride din rate.

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}

Til funktionskald (Function Calling)

Funktionskald bedømmes på to akser, der skal måles separat. En model, der vælger den rigtige funktion, men får parameteren forkert, fejler anderledes end en, der kalder det helt forkerte værktøj: det første problem løses med udtrækningseksempler, det andet med diskriminationseksempler. En enkelt global score ville sløre denne distinktion og efterlade dig blind i arbejdet.

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

Menneskelig evaluering

Automatiseret evaluering fanger ikke alt. En let nedladende tone, en formulering, der ikke falder i god jord hos dine kunder, et teknisk korrekt men ubrugeligt svar: disse fejl viser sig kun under et menneskeligt øje. Protokollen er ligetil. Udtag tyve til halvtreds svar tilfældigt, aldrig de tilfælde, du allerede har flagget som problematiske, ellers måler du blot din egen selektionsbias. Definer derefter klare, målbare kriterier og formaliser dem i en standardiseret scoringsskala, så to anmeldere bedømmer det samme.

Lad til sidst flere personer evaluere og beregn enigheden mellem bedømmerne (inter-rater agreement). Stor uenighed signalerer ikke nødvendigvis en dårlig model: oftest afslører det, at din skala stadig er tvetydig og behöver afklaring, før du kan konkludere noget.

Eksempel på evalueringsskala

Kriterium 1 (Dårlig) 3 (Acceptabel) 5 (Fremragende)
Relevans Uden for emnet Delvist relevant Perfekt målrettet
Tone Upassende Acceptabel men flad Perfekt afstemt
Format Ikke fulgt Delvist fulgt Perfekt fulgt

Evalueringsrapport

Én sidste refleks adskiller en evaluering fra en beslutning: registrér begge resultatfamilier i en enkelt rapport, ledsaget af en eksplicit anbefaling. Den tærskel, du sætter – her et menneskeligt gennemsnit på 4 for at gå i produktion, 3 for at iterere på data – skal vælges før lanceringen af kampagnen. Besluttet bagefter justerer den sig altid til det resultat, du håbede på.

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")

Vigtige pointer

  • Adskil altid et uafhængigt testsæt (hverken træning eller validering)
  • Kombinér automatiseret og menneskelig evaluering
  • LLM-as-a-judge-evaluering er et godt kompromis mellem de to
  • Definer målbare kriterier, før du starter
  • En lav tab-score (low loss) garanterer ikke produktionskvalitet