Datakvalitet: Rensning og validering
På denne side
Opdatering 2. november 2026 — Tilgængelighed af fine-tuning. OpenAIs selvbetjente fine-tuning udfases: Fra den 7. maj 2026 kan organisationer, der aldrig har kørt en fine-tuning-opgave, ikke længere oprette en; siden den 2. juli skal du have brugt en fine-tunet model inden for de sidste 60 dage; og fra den 6. januar 2027 vil ingen kunde kunne starte nye opgaver. 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 rensning er afgørende
En teknisk gyldig JSONL-fil garanterer ikke god fine-tuning. Støjende, inkonsistente eller dårligt formaterede data vil forringe modellens ydeevne i stedet for at forbedre den – og det værste er, at det ikke udløser nogen fejl. Opgaven vil lykkes, modellen vil være klar, og du vil først opdage problemet i produktionen. Denne lektion dækker de rensnings- og valideringsteknikker, du bør køre før upload.
Teknisk filvalidering
Start med mekanikken: verificér, at din fil er syntaktisk korrekt, og at hver linje overholder den forventede kontrakt. Funktionen nedenfor gennemgår filen linje for linje, akkumulerer fejl i stedet for at stoppe ved den første (du vil have hele listen, ikke frem og tilbage for hvert problem) og returnerer nogle nyttige statistikker undervejs, såsom tilstedeværelsen af systembeskeder og samtaler med flere tur.
import json
def validate_jsonl(path: str) -> dict:
"""Validates a JSONL file and returns statistics."""
errors = []
stats = {"total": 0, "with_system": 0, "multi_turn": 0}
valid_roles = {"system", "user", "assistant"}
with open(path, "r", encoding="utf-8") as f:
for i, line in enumerate(f, 1):
stats["total"] += 1
try:
obj = json.loads(line.strip())
except json.JSONDecodeError as e:
errors.append(f"Line {i}: Invalid JSON — {e}")
continue
if "messages" not in obj:
errors.append(f"Line {i}: Missing 'messages' key")
continue
messages = obj["messages"]
if not isinstance(messages, list) or len(messages) < 2:
errors.append(f"Line {i}: Minimum 2 messages required")
continue
for j, msg in enumerate(messages):
role = msg.get("role")
if role not in valid_roles:
errors.append(f"Line {i}, msg {j}: Invalid role")
if not msg.get("content", "").strip():
errors.append(f"Line {i}, msg {j}: Empty content")
if not any(m["role"] == "assistant" for m in messages):
errors.append(f"Line {i}: No assistant message")
if messages[0]["role"] == "system":
stats["with_system"] += 1
user_turns = sum(1 for m in messages if m["role"] == "user")
if user_turns > 1:
stats["multi_turn"] += 1
return {"errors": errors, "stats": stats}
result = validate_jsonl("training_data.jsonl")
if result["errors"]:
print(f"Errors: {len(result['errors'])}")
for err in result["errors"][:10]:
print(f" - {err}")
else:
print(f"File valid — {result['stats']['total']} examples")
Rensning af indhold
Nøjagtige eller næsten duplikerede poster skævvrider træningen ved at overrepræsentere bestemte mønstre. Dette sker naturligt, når du samler flere eksporter: det samme hyppige spørgsmål optræder tredive gange i dine logs, og modellen konkluderer, at det fortjener tredive gange mere opmærksomhed end andre. En hash af det sammenkædede beskedindhold er nok til at eliminere dem.
import hashlib
def deduplicate(examples: list[dict]) -> list[dict]:
"""Removes duplicates based on message content."""
seen = set()
unique = []
for ex in examples:
content = "|".join(
f"{m['role']}:{m['content']}" for m in ex["messages"]
)
h = hashlib.md5(content.encode()).hexdigest()
if h not in seen:
seen.add(h)
unique.append(ex)
print(f"Duplicates removed: {len(examples) - len(unique)}")
return unique
Dernæst kommer tekstnormalisering, som adresserer fire forskellige problemer. Flere mellemrum og overflødige linjeskift, arvet fra kopiering og indsætning, skal væk. Kodning skal normaliseres til UTF-8 med kontroltegn fjernet – usynlige, men ofte til stede i databaseeksporter. Tegnsætning fortjener et tjek: et svar, der afbrydes midt i, lærer modellen at afbryde sig selv. Sørg endelig for sprogkonsistens – hvis du ønsker formel tiltaleform, så verificér, at intet eksempel bruger uformel tiltaleform, for modellen vil trofast reproducere blandingen.
import re
import unicodedata
def normalize_text(text: str) -> str:
"""Normalizes text for training."""
text = unicodedata.normalize("NFC", text)
text = re.sub(r"[\x00-\x09\x0b-\x0c\x0e-\x1f\x7f]", "", text)
text = re.sub(r"[ \t]+", " ", text)
text = re.sub(r"\n{3,}", "\n\n", text)
return text.strip()
Konsistenskontroller
Hvis du bruger en systembesked, skal den være strengt identisk på tværs af alle dine eksempler. To varianter, der kun adskiller sig med ét ord, er nok til at udvande signalet: modellen holder op med at lære en specifik instruktion og begynder i stedet at lære en sløret familie af instruktioner. Tjekket er trivielt, og resultatet er ofte overraskende på et korpus bygget af flere personer.
def check_system_messages(examples: list[dict]):
"""Checks consistency of system messages."""
system_msgs = set()
for ex in examples:
for msg in ex["messages"]:
if msg["role"] == "system":
system_msgs.add(msg["content"].strip())
if len(system_msgs) > 1:
print(f"Warning: {len(system_msgs)} different system messages")
for sm in system_msgs:
print(f" - {sm[:80]}...")
elif len(system_msgs) == 1:
print("System message consistent")
else:
print("No system message used")
Fordelingen af svarlængder fortæller den samme historie fra en anden vinkel. Meget heterogene svar signalerer, at flere personer har skrevet korpussen med forskellige idéer om, hvordan et godt svar ser ud, eller at en outlier er snuppet ind i batchen. Tærsklen, der bruges her – et maksimum større end fem gange gennemsnittet – er ikke absolut, men den leder dit blik hen på det rigtige sted.
def analyze_lengths(examples: list[dict]):
"""Analyzes the distribution of response lengths."""
lengths = []
for ex in examples:
for msg in ex["messages"]:
if msg["role"] == "assistant":
lengths.append(len(msg["content"]))
if lengths:
avg = sum(lengths) / len(lengths)
mini, maxi = min(lengths), max(lengths)
print(f"Response length — Avg: {avg:.0f} | Min: {mini} | Max: {maxi}")
if maxi > avg * 5:
print("High dispersion — check for outliers")
Brug af OpenAIs validerings-API
Når du har kørt dine egne tjek, skal du uploade filen og lade OpenAI validere den også. Det er gratis, øjeblikkeligt og sparer dig for at opdage et formatproblem, når opgaven starter.
from openai import OpenAI
client = OpenAI()
file = client.files.create(
file=open("training_data.jsonl", "rb"),
purpose="fine-tune"
)
print(f"File uploaded: {file.id}")
print(f"Status: {file.status}")
Hvis filen indeholder fejl, vil statussen ændre sig til error med en detaljeret besked. Ret de rapporterede problemer, før du prøver igen.
Tjekliste før fine-tuning
Gå denne liste igennem i rækkefølge, før du opretter opgaven – hvert punkt svarer til et tjek dækt ovenfor, bortset fra det sidste, som intet script kan erstatte:
- JSONL-filen er syntaktisk gyldig
- Ingen duplikater
- Tekst normaliseret (UTF-8, mellemrum, tegnsætning)
- Systembeskeder er konsistente
- Mindst 50 eksempler (ideelt set 100+)
- Opdeling i trænings-/valideringssæt udført
- Rimelig fordeling af længder
- Menneskelig gennemgang af en tilfældig stikprøve
Vigtige pointer
- Valider altid JSONL-syntaks før upload
- Fjern duplikater for at undgå overtilpasning
- Konsistens i systembeskeder er afgørende
- Tjek fordelingen af svarlængder
- Lad et menneske gennemgå en stikprøve – det er uerstatteligt