Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Kvalita údajov: čistenie a validácia

Lekcia 4 z 16 Aktualizované 2. novembra 2026 Pokročilý
Na tejto strane
  1. Prečo je čistenie kritické
  2. Technická validácia súboru
  3. Čistenie obsahu
  4. Kontroly konzistencie
  5. Používanie validačného API OpenAI
  6. Kontrolný zoznam pred jemným doladením
  7. Kľúčové poznatky

Aktualizácia 2. novembra 2026 — Dostupnosť jemného doladenia. Služba vlastného jemného doladenia od OpenAI sa postupne ukončuje: od 7. mája 2026 organizácie, ktoré nikdy nespustili úlohu jemného doladenia, už nemôžu vytvoriť novú; od 2. júla musíte mať použitý jemne doladený model za posledných 60 dní; a počnúc 6. januárom 2027 žiadny zákazník nebude môcť spustiť nové úlohy. Už natrénované modely zostávajú použiteľné až do vyradenia ich základného modelu. Tento kurz zostáva užitočný na pochopenie a využitie existujúceho modelu; pri nových projektoch uprednostnite inžinierstvo promptov, RAG a evaluácie.

Prečo je čistenie kritické

Technicky platný súbor JSONL nezaručuje dobré jemné doladenie. Hlučné, nekonzistentné alebo zle formátované údaje zhoršia výkon modelu namiesto toho, aby ho zlepšili – a to najhoršie je, že nespustia žiadne chyby. Úloha úspešne prebehne, model bude pripravený a problém objavíš až v produkcii. Táto lekcia pokrýva techniky čistenia a validácie, ktoré by si mal spustiť pred nahraním.

Technická validácia súboru

Začni mechanikou: over, či je tvoj súbor syntakticky správny a či každý riadok dodržiava očakávanú zmluvu. Funkcia nižšie prechádza súbor riadok po riadku, akumuluje chyby namiesto zastavenia pri prvej z nich (chceš úplný zoznam, nie behanie tam a späť pre každý problém) a cestou vracia užitočné štatistiky, ako je prítomnosť systémových správ alebo konverzácií s viacerými kolami.

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

Čistenie obsahu

Presné alebo takmer identické duplicitné záznamy skresľujú trénovanie tým, že nadmerne zastupujú určité vzorce. K tomu dochádza prirodzene pri agregácii viacerých exportov: tá istá častá otázka sa v logoch objaví tridsaťkrát a model dospieje k záveru, že si zaslúži tridsaťkrát väčšiu pozornosť než ostatné. Na ich odstránenie stačí hash zreťazeného obsahu správ.

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

Ďalej prichádza normalizácia textu, ktorá rieši štyri odlišné problémy. Musia zmiznúť viacnásobné medzery a nadbytočné zalomenia riadkov, ktoré vznikli kopírovaním a vkladaním. Kódovanie sa musí normalizovať na UTF-8 s odstránenými kontrolnými znakmi – sú neviditeľné, no často prítomné v exportoch z databáz. Interpunkcia si zaslúži kontrolu: odpoveď prerušená v polovici učí model, aby sa sám prerušoval. Nakoniec zabezpeč konzistentnosť jazyka – ak chceš formálne oslovenie, over, či žiadna ukážka nepoužíva neformálne oslovenie, pretože model túto zmes verne reprodukuje.

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

Kontroly konzistencie

Ak používaš systémovú správu, musí byť vo všetkých ukážkach rigorózne identická. Dva varianty, ktoré sa líšia len jedným slovom, stačia na zriedenie signálu: model prestane学习ť konkrétny pokyn a začne sa učiť rozmazanú rodinu pokynov. Kontrola je triviálna a výsledok je často prekvapivý pri korpuse zostavenom viacerými ľuďmi.

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

Rozdelenie dĺžok odpovedí rozpráva ten istý príbeh z iného uhla. Veľmi heterogénne odpovede signalizujú, že korpus písalo viacero ľudí s rôznymi predstavami o tom, ako má dobrá odpoveď vyzerať, alebo že sa do dávky dostala odľahlá hodnota. Prah použitý tu – maximum väčšie ako päťnásobok priemeru – nie je absolútny, ale nasmeruje tvoju pozornosť na správne miesto.

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

Používanie validačného API OpenAI

Keď si spustil vlastné kontroly, nahraj súbor a nechaj ho validovať aj OpenAI. Je to zadarmo, okamžité a ušetrí ti to objavovanie problémov s formátom až pri štarte úlohy.

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

Ak súbor obsahuje chyby, stav sa zmení na error s podrobnou správou. Pred opakovaným pokusom oprav nahlásené problémy.

Kontrolný zoznam pred jemným doladením

Prejdi si tento zoznam v poradí pred vytvorením úlohy – každá položka zodpovedá vyššie uvedenej kontrole, okrem poslednej, ktorú žiadny skript nenahradí:

  • Súbor JSONL je syntakticky platný
  • Žiadne duplikáty
  • Text normalizovaný (UTF-8, medzery, interpunkcia)
  • Systémové správy sú konzistentné
  • Aspoň 50 ukážok (ideálne 100+)
  • Vykonané rozdelenie na trénovaciu a validačnú množinu
  • Rozumné rozdelenie dĺžok
  • Ľudská kontrola náhodnej vzorky

Kľúčové poznatky

  • Vždy validuj syntax JSONL pred nahraním
  • Odstráň duplikáty, aby sa predišlo preučeniu
  • Konzistentnosť systémovej správy je nevyhnutná
  • Skontroluj rozdelenie dĺžok odpovedí
  • Nechaj človeka skontrolovať vzorku – je to nenahraditeľné