Evaluér din finjusterede model
På denne side
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