Utvärdera din finjusterade modell
På denna sida
Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningstjänst för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig har använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med den 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.
Varför utvärdering är avgörande
En lyckad finjustering mäts inte enbart av förlustfunktionen (loss). Den verkliga frågan är: är din finjusterade modell faktiskt bättre än basmodellen för ditt användningsområde? En jämnt sjunkande kurva bevisar bara att modellen har lärt sig att reproducera dina exempel; den säger ingenting om hur den beter sig vid oseen förfrågningar. I denna lektion visar vi hur du bygger en rigorös utvärderingsprotokoll som kombinerar automatiserade metrik, LLM-baserad bedömning och mänsklig granskning.
Bygga en testmängd
Din testmängd måste vara separat från både din tränings- och valideringsdata. Distinktionen är viktig: valideringsmängden övervakar träningen och påverkar därmed dina hyperparameterbeslut, vilket gradvis kontaminerar den. Testmängden öppnas däremot först när modellen är fryst. Den representerar de situationer i verkliga livet som din modell kommer att möta i produktion, med samma proportioner av enkla och knepiga fall. En uppdelning på 80/10/10 av en tidigare blandad korpus är en rimlig utgångspunkt.
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")
Automatiserad utvärdering
Metrikbaserad utvärdering
Principen är enkel: för varje testexempel tar du bort assistentmeddelandet – det är det förväntade svaret som modellen inte får se – skickar in resten och behåller inmatningen, referenssvaret och det genererade svaret sida vid sida. Denna trespaltsstruktur är grunden för allt som följer; att använda den för metrikberäkning eller kvalitativ bedömning är bara en fråga om efterföljande bearbetning.
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
Utvärdering med LLM som domare
En kraftfull teknik är att använda en högpresterande modell för att bedöma svarskvaliteten. Ord-för-ord-jämförelse med referensen blir oanvändbar så snart flera formuleringar är acceptabla; en domare uppskattar däremot substansen. Kvaliteten på dess omdöme beror helt på precisionen i prompten: fyra kriterier betygsatta från 1 till 5, ett tvingat JSON-utdata och en fritextkommentar som du senare använder för att förstå misslyckanden. Planera för fall där utdatan inte går att parsa istället för att låta ett undantag avbryta kampanjen.
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
Specialiserade metrik
De två tidigare metoderna fungerar bra för skrivna svar. Så snart din models utdata har en fast struktur blir mer direkta mått möjliga och sparar dig omvägen via en domare.
För klassificering
När den förväntade utdatan tillhör en sluten mängd – en ticketkategori, en sentimentanalys, en produktkod – blir exakt matchning återigen relevant. Normalisera skiftläge och mellanslag innan jämförelse; annars kommer “Urgent” kontra “urgent” att räknas som ett fel och snedvrida din procentsats.
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}
För funktionsanrop (Function Calling)
Funktionsanrop bedöms på två axlar som måste mätas separat. En modell som väljer rätt funktion men får parametern fel misslyckas på ett annat sätt än en som anropar helt fel verktyg: det första problemet löses med extraktionsexempel, det andra med diskrimineringsexempel. Ett enda globalt betyg skulle dölja denna distinktion och lämna dig att arbeta i blindo.
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
Mänsklig utvärdering
Automatiserad utvärdering fångar inte allt. En lätt nedlåtande ton, en fras som inte faller dina kunder i smaken, ett tekniskt korrekt men oanvändbart svar: dessa brister syns bara under ett mänskligt öga. Protokollet är rakt på sak. Sampla tjugo till femtio svar slumpmässigt, aldrig de fall du redan flaggat som problematiska, annars mäter du bara ditt eget urvalsbias. Definiera sedan tydliga, mätbara kriterier och formalisera dem i en standardiserad bedömningsmall så att två granskare bedömer samma sak.
Låt slutligen flera personer utvärdera och beräkna överensstämmelsen mellan bedömarna (inter-rater agreement). Stor oenighet signalerar inte nödvändigtvis en dålig modell: oftast avslöjar den att din bedömningsmall fortfarande är tvetydig och behöver förtydligas innan du kan dra några slutsatser.
Exempel på bedömningsmall
| Kriterium | 1 (Dåligt) | 3 (Acceptabelt) | 5 (Utmärkt) |
|---|---|---|---|
| Relevans | Inte relevant | Delvis relevant | Perfekt målinriktad |
| Ton | Olämplig | Acceptabel men platt | Perfekt anpassad |
| Format | Inte följt | Delvis följt | Perfekt följt |
Utvärderingsrapport
En sista reflex skiljer en utvärdering från ett beslut: dokumentera båda familjerna av resultat i en enda rapport, åtföljd av en explicit rekommendation. Tröskeln du sätter – här ett mänskligt medelvärde på 4 för att gå till produktion, 3 för att iterera på data – måste väljas innan du startar kampanjen. Beslutas den efteråt justeras den alltid till det resultat du hoppades 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")
Viktiga punkter
- Håll alltid en oberoende testmängd separat (varken tränings- eller valideringsdata)
- Kombinera automatiserad och mänsklig utvärdering
- Utvärdering med LLM som domare är en bra kompromiss mellan de två
- Definiera mätbara kriterier innan du börjar
- Ett lågt förlustvärde garanterar inte produktionskvalitet