Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Kwaliteit van gegevens: opschonen en valideren

Les 4 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom opschonen cruciaal is
  2. Technische bestandsvalidatie
  3. Opschonen van inhoud
  4. Consistentiecontroles
  5. De OpenAI-validatie-API gebruiken
  6. Checklist voorafgaand aan fine-tuning
  7. Belangrijkste punten

Update 2 november 2026 — Beschikbaarheid van fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd afgebouwd: vanaf 7 mei 2026 kunnen organisaties die nog nooit een fine-tuning-taak hebben uitgevoerd, geen nieuwe meer aanmaken; sinds 2 juli moet u binnen de laatste 60 dagen een gefinetuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nog nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.

Waarom opschonen cruciaal is

Een technisch geldig JSONL-bestand garandeert geen goede fine-tuning. Ruisende, inconsistente of slecht geformatteerde gegevens zullen de prestaties van het model verslechteren in plaats van verbeteren – en het ergste is dat dit geen fouten zal genereren. De taak slaagt, het model is klaar, en u ontdekt het probleem pas in productie. Deze les behandelt de opschonings- en validatietechnieken die u moet uitvoeren voordat u uploadt.

Technische bestandsvalidatie

Begin met de mechanica: verifieer dat uw bestand syntactisch correct is en dat elke regel voldoet aan het verwachte contract. De onderstaande functie doorloopt het bestand regel voor regel, verzamelt fouten in plaats van te stoppen bij de eerste (u wilt de volledige lijst, niet heen en weer voor elk probleem) en retourneert onderweg enkele nuttige statistieken, zoals de aanwezigheid van systeemberichten en conversaties met meerdere beurten.

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

Opschonen van inhoud

Exacte of bijna-dubbele vermeldingen bevoordelen de training door bepaalde patronen overmatig weer te geven. Dit gebeurt natuurlijk wanneer u meerdere exports samenvoegt: dezelfde frequente vraag dertig keer in uw logs, en het model concludeert dat deze dertig keer meer aandacht verdient dan andere. Een hash van de samengevoegde berichtinhoud volstaat om ze te elimineren.

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

Vervolgens komt tekstnormalisatie, die vier verschillende problemen aanpakt. Meervoudige spaties en overbodige regeleinden, overgeërfd van kopiëren en plakken, moeten verdwijnen. Codering moet worden genormaliseerd naar UTF-8 met verwijderde besturingstekens – onzichtbaar maar vaak aanwezig in database-exports. Leestekens verdienen een controle: een reactie die halverwege wordt afgebroken, leert het model zichzelf te onderbreken. Zorg ten slotte voor taalconsistentie: als u formeel taalgebruik wilt, verifieer dan dat geen enkel voorbeeld informeel taalgebruik bevat, omdat het model de mix trouw zal reproduceren.

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

Consistentiecontroles

Als u een systeembericht gebruikt, moet dit strikt identiek zijn in al uw voorbeelden. Twee varianten die slechts één woord verschillen, volstaan om het signaal te verdunnen: het model stopt met het leren van een specifieke instructie en begint een wazige familie van instructies te leren. De controle is triviaal en het resultaat is vaak verrassend bij een corpus dat door meerdere personen is opgebouwd.

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

De verdeling van responslengtes vertelt hetzelfde verhaal vanuit een andere hoek. Zeer heterogene responsen signaleren dat meerdere personen het corpus hebben geschreven met verschillende ideeën over hoe een goed antwoord eruitziet, of dat een uitschieter in de batch is geslopen. De hier gebruikte drempel – een maximum dat meer dan vijf keer het gemiddelde is – is niet absoluut, maar vestigt uw aandacht op de juiste plek.

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

De OpenAI-validatie-API gebruiken

Nadat u uw eigen controles heeft uitgevoerd, uploadt u het bestand en laat u OpenAI het ook valideren. Het is gratis, onmiddellijk en bespaart u de ontdekking van een formaatprobleem wanneer de taak start.

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

Als het bestand fouten bevat, verandert de status in error met een gedetailleerd bericht. Los de gerapporteerde problemen op voordat u het opnieuw probeert.

Checklist voorafgaand aan fine-tuning

Doorloop deze lijst op volgorde voordat u de taak aanmaakt – elk item komt overeen met een hierboven behandelde controle, behalve de laatste, die door geen enkel script kan worden vervangen:

  • JSONL-bestand is syntactisch geldig
  • Geen duplicaten
  • Tekst genormaliseerd (UTF-8, spaties, leestekens)
  • Systeemberichten zijn consistent
  • Minimaal 50 voorbeelden (idealiter 100+)
  • Train/validatie-splitsing uitgevoerd
  • Redelijke verdeling van lengtes
  • Menselijke beoordeling van een willekeurige steekproef

Belangrijkste punten

  • Valideer altijd de JSONL-syntax voordat u uploadt
  • Verwijder duplicaten om overfitting te voorkomen
  • Consistentie van systeemberichten is essentieel
  • Controleer de verdeling van responslengtes
  • Laat een mens een steekproef beoordelen – dit is onvervangbaar