Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Adatminőség: tisztítás és validálás

4. lecke 16 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. Miért kritikus a tisztítás?
  2. Technikai fájlvalidálás
  3. Tartalmi tisztítás
  4. Konzisztencia-ellenőrzések
  5. Az OpenAI validálási API használata
  6. Finomhangolás előtti ellenőrzőlista
  7. Főbb megállapítások

Frissítés: 2026. november 2. — Finomhangolás elérhetősége. Az OpenAI saját kiszolgálású finomhangolási szolgáltatását fokozatosan megszüntetik: 2026. május 7-től azok a szervezetek, amelyek még sosem futtattak finomhangolási feladatot, már nem hozhatnak létre újat; július 2 óta pedig az elmúlt 60 napban használnod kellett egy finomhangolt modellt; 2027. január 6-tól pedig egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljüket ki nem vonják. Ez a tananyag továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén azonban a prompt-mérnökséget, a RAG-ot és az értékeléseket kell előtérbe helyezned.

Miért kritikus a tisztítás?

Egy technikailag érvényes JSONL-fájl még nem garantálja a jó finomhangolást. A zajos, inkonzisztens vagy rosszul formázott adatok rontják a modell teljesítményét ahelyett, hogy javítanák – és a legrosszabb az egészben az, hogy ez nem vált ki semmilyen hibát. A feladat sikeresen lefut, a modell készen áll, és te csak éles környezetben szembesülsz a problémával. Ez a lecke azokat a tisztítási és validálási technikákat mutatja be, amelyeket a feltöltés előtt futtatnod kell.

Technikai fájlvalidálás

Kezdjük a mechanikával: ellenőrizd, hogy a fájlod szintaktikailag helyes-e, és hogy minden sor megfelel-e az elvárt szerződésnek. Az alábbi függvény soronként végigmegy a fájlon, és ahelyett, hogy az első hibánál megállna, gyűjti a hibákat (így a teljes listát kapod meg, nem pedig oda-vissza kommunikálsz minden egyes problémáról), valamint hasznos statisztikákat is visszaad menet közben, például a rendszerüzenetek jelenlétét vagy a többfordulós beszélgetéseket.

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

Tartalmi tisztítás

A pontos vagy közel azonos duplikált bejegyzések torzítják a tanítást azáltal, hogy bizonyos mintákat túlreprezentálnak. Ez természetesen előfordul, amikor több exportot aggregálsz: ugyanaz a gyakori kérdés harmincszor is megjelenik a naplóidban, és a modell arra a következtetésre jut, hogy harmincszor nagyobb figyelmet érdemel, mint a többi. A konkatenált üzenettartalom hash-értéke elegendő ezek eltávolításához.

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

Ezt követi a szöveg normalizálása, amely négy különböző problémát kezel. A másolás-beillesztésből származó többszörös szóközöket és felesleges sortöréseket el kell távolítani. A kódolást UTF-8-ra kell normalizálni, eltávolítva a vezérlőkaraktereket – ezek láthatatlanok, de gyakran jelen vannak az adatbázis-exportokban. A központozást is ellenőrizni kell: egy félbevágott válasz arra tanítja a modellt, hogy szakítsa meg önmagát. Végül biztosítsd a nyelvi konzisztenciát: ha tegezést szeretnél, ellenőrizd, hogy egyetlen példa sem használ magázást, mert a modell hűségesen reprodukálni fogja a keveréket.

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

Konzisztencia-ellenőrzések

Ha rendszerüzenetet használsz, annak szigorúan azonosnak kell lennie az összes példádban. Két variáns, amely csak egy szóban tér el, elegendő ahhoz, hogy felhígítsa a jelet: a modell abbahagyja egy specifikus utasítás megtanulását, és helyette utasítások egy elmosódott családját kezdi el tanulni. Az ellenőrzés triviális, az eredmény azonban gyakran meglepő egy több ember által összeállított korpusz esetén.

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

A válaszok hosszának eloszlása másik szemszögből meséli el ugyanezt a történetet. A rendkívül heterogén válaszok arra utalnak, hogy többen írták a korpuszt eltérő elképzelésekkel arról, hogyan néz ki egy jó válasz, vagy hogy egy kiugró érték csúszott be a kötegbe. Az itt használt küszöbérték – maximum, amely ötszöröse az átlagnak – nem abszolút, de segít oda irányítani a figyelmedet, ahol szükség van rá.

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

Az OpenAI validálási API használata

Miután lefuttattad a saját ellenőrzéseidet, töltsd fel a fájlt, és hagyd, hogy az OpenAI is validálja azt. Ez ingyenes, azonnali, és megkímél attól, hogy formátumhibát fedezz fel, amikor a feladat már elindult.

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

Ha a fájl hibákat tartalmaz, az állapot error-ra változik egy részletes üzenettel. A újrapróbálkozás előtt javítsd a jelzett problémákat.

Finomhangolás előtti ellenőrzőlista

Mielőtt létrehoznád a feladatot, haladj végig ezen a listán sorrendben – minden pont a fent tárgyalt ellenőrzések egyikének felel meg, kivéve az utolsót, amelyet egyetlen szkript sem helyettesíthet:

  • A JSONL-fájl szintaktikailag érvényes
  • Nincsenek duplikáltumok
  • A szöveg normalizálva van (UTF-8, szóközök, központozás)
  • A rendszerüzenetek konzisztensek
  • Legalább 50 példa (ideális esetben 100+)
  • A tanító/validáló felosztás megtörtént
  • Ésszerű hossz-eloszlás
  • Emberi átnézés egy véletlenszerű mintán

Főbb megállapítások

  • Feltöltés előtt mindig validáld a JSONL szintaxist
  • Távolítsd el a duplikáltumokat a túlillesztés elkerülése érdekében
  • A rendszerüzenetek konzisztenciája elengedhetetlen
  • Ellenőrizd a válaszok hosszának eloszlását
  • Hagyd, hogy egy ember átnézzen egy mintát – ezt semmi sem pótolhatja