Datakvalitet: Rengöring och validering
På denna sida
Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningstjänst för finjustering avvecklas: från och med den 7 maj 2026 kan organisationer som aldrig tidigare kört ett finjusteringsjobb inte längre skapa ett; sedan den 2 juli måste du ha använt en finjusterad modell inom 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 bort. Den här kursen är fortfarande värdefull 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 rengöring är avgörande
En tekniskt giltig JSONL-fil garanterar inte bra finjustering. Brusiga, inkonsekventa eller dåligt formaterade data försämrar modellens prestanda istället för att förbättra den – och det värsta är att det inte utlöser några felmeddelanden. Jobbet slutförs, modellen blir redo, och du upptäcker problemet först i produktion. Den här lektionen täcker de rengörings- och valideringstekniker du bör köra innan uppladdning.
Teknisk filvalidering
Börja med mekaniken: verifiera att din fil är syntaktiskt korrekt och att varje rad följer det förväntade kontraktet. Funktionen nedan går igenom filen rad för rad, samlar på sig fel istället för att stanna vid det första (du vill ha hela listan, inte ett fram och tillbaka för varje problem) och returnerar användbar statistik på vägen, såsom förekomsten av systemmeddelanden och flerstegskonversationer.
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")
Innehållsrengöring
Exakta eller nästan identiska dubbletter snedvrider träningen genom att överrepresentera vissa mönster. Detta sker naturligt när du sammanställer flera exporter: samma vanliga fråga dyker upp trettio gånger i dina loggar, och modellen drar slutsatsen att den förtjänar trettio gånger mer uppmärksamhet än andra. En hash av det sammanslagna meddelandeinnehållet räcker för att eliminera 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
Därefter kommer textnormalisering, som hanterar fyra distinkta problem. Flera mellanslag och onödiga radbrytningar, som ofta följer med vid kopiering och klistring, måste bort. Kodningen måste normaliseras till UTF-8 med kontrolltecken borttagna – osynliga men ofta förekommande i databasexporter. Interpunktion förtjänar en kontroll: ett svar som trunkeras mitt i lär modellen att avbryta sig själv. Slutligen, säkerställ språklig konsekvens – om du vill ha formellt tilltal, verifiera att inget exempel använder informellt tilltal, eftersom modellen troget kommer att reproducera blandningen.
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
Om du använder ett systemmeddelande måste det vara rigoröst identiskt i alla dina exempel. Två varianter som skiljer sig åt med bara ett ord räcker för att utspäda signalen: modellen slutar lära sig en specifik instruktion och börjar istället lära sig en diffus familj av instruktioner. Kontrollen är trivial, och resultatet är ofta överraskande på en korpus som byggts av flera 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")
Fördelningen av svarslängder berättar samma historia från en annan vinkel. Mycket heterogena svar signalerar att flera personer har skrivit korpusen med olika uppfattningar om hur ett bra svar ser ut, eller att en avvikare har smugit sig in i batchen. Tröskeln som används här – ett maximum som är större än fem gånger genomsnittet – är inte absolut, men den drar din uppmärksamhet till rätt ställe.
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")
Använda OpenAIs validerings-API
När du har kört dina egna kontroller laddar du upp filen och låter OpenAI validera den också. Det är gratis, omedelbart och sparar dig från att upptäcka ett formatfel när jobbet väl startar.
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}")
Om filen innehåller fel kommer statusen att ändras till error med ett detaljerat meddelande. Åtgärda de rapporterade problemen innan du försöker igen.
Checklista inför finjustering
Gå igenom denna lista i ordning innan du skapar jobbet – varje punkt motsvarar en kontroll som täckts ovan, utom den sista, som inget skript kan ersätta:
- JSONL-filen är syntaktiskt giltig
- Inga dubbletter finns
- Texten är normaliserad (UTF-8, mellanslag, interpunktion)
- Systemmeddelanden är konsekventa
- Minst 50 exempel (helst 100+)
- Uppdelning i tränings- och valideringsdata är gjord
- Rimlig fördelning av längder
- Mänsklig granskning av ett slumpmässigt urval
Viktiga punkter
- Validera alltid JSONL-syntaxen innan uppladdning
- Ta bort dubbletter för att undvika överanpassning
- Konsistens i systemmeddelanden är avgörande
- Kontrollera fördelningen av svarslängder
- Låt en människa granska ett urval – det är oersättligt