Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Kvalita dat: čištění a validace

Lekce 4 z 16 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Proč je čištění zásadní
  2. Technická validace souboru
  3. Čištění obsahu
  4. Kontroly konzistence
  5. Použití validačního API OpenAI
  6. Kontrolní seznam před jemným laděním
  7. Klíčové poznatky

Aktualizace 2. listopadu 2026 — Dostupnost jemného ladění. Služba vlastního jemného ladění OpenAI se postupně ukončuje: od 7. května 2026 organizace, které nikdy nespustily úlohu jemného ladění, již nemohou vytvořit novou; od 2. července musíte mít model s jemným laděním použitý během posledních 60 dnů; a počínaje 6. lednem 2027 žádný zákazník nebude moci spustit nové úlohy. Již natrénované modely zůstávají použitelné až do vyřazení jejich základního modelu. Tento kurz je stále užitečný pro pochopení a využití existujícího modelu; u nových projektů upřednostňujte inženýrství promptů, RAG a evaluace.

Proč je čištění zásadní

Technicky platný soubor JSONL nezaručuje dobré jemné ladění. Hlučná, nekonzistentní nebo špatně formátovaná data spíše zhorší výkon modelu, než aby jej zlepšila – a to nejhorší je, že nevyvolají žádné chyby. Úloha proběhne úspěšně, model bude připraven a problém zjistíte až v produkci. Tato lekce pokrývá techniky čištění a validace, které byste měli provést před nahráním dat.

Technická validace souboru

Začni mechanikou: ověř, že je tvůj soubor syntakticky správný a že každý řádek respektuje očekávanou smlouvu. Níže uvedená funkce prochází soubor řádek po řádku, hromadí chyby místo zastavení u první z nich (chceš mít úplný seznam, ne běhat tam a zpět pro každý problém) a cestou vrací užitečné statistiky, jako je přítomnost systémových zpráv nebo konverzací s více obraty.

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

Čištění obsahu

Přesné nebo téměř identické duplicitní záznamy zaujatě ovlivňují trénování tím, že nadměrně reprezentují určité vzorce. K tomu dochází přirozeně při agregaci více exportů: stejná častá otázka se v logách objeví třicetkrát a model dojde k závěru, že si zaslouží třicetkrát více pozornosti než ostatní. K jejich eliminaci stačí hash spojeného obsahu zprá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

Další na řadě je normalizace textu, která řeší čtyři odlišné problémy. Je třeba odstranit násobné mezery a nadbytečné odřádkování zděděné po kopírování a vkládání. Kódování musí být normalizováno na UTF-8 s odstraněnými řídicími znaky – jsou neviditelné, ale v exportech z databází se často vyskytují. Interpunkce si zaslouží kontrolu: odpověď useknutá uprostřed naučí model, aby se sám přerušoval. Nakonec zajisti jazykovou konzistenci – pokud chceš vykání, ověř, že žádný příklad nepoužívá tykání, protože model věrně reprodukuje směsici obojího.

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 konzistence

Pokud používáš systémovou zprávu, musí být ve všech příkladech rigorózně identická. Dvě varianty lišící se jediným slovem stačí k rozředění signálu: model se přestane učit konkrétní instrukci a začne se učit rozmazanou rodinu instrukcí. Kontrola je triviální a výsledek bývá často překvapivý u korpusu tvořeného více lidmi.

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

Rozdělení délek odpovědí vypráví stejný příběh z jiného úhlu. Vysoce heterogenní odpovědi signalizují, že korpus psalo více lidí s různými představami o tom, jak má dobrá odpověď vypadat, nebo že se do dávky dostala odlehlá hodnota. Zde použitý práh – maximum větší než pětinásobek průměru – není absolutní, ale nasměruje tvou pozornost na správné místo.

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žití validačního API OpenAI

Jakmile provedeš vlastní kontroly, nahraj soubor a nech jej validovat také OpenAI. Je to zdarma, okamžité a ušetří ti to odhalení formátové chyby až při startu ú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}")

Pokud soubor obsahuje chyby, stav se změní na error s podrobnou zprávou. Před dalším pokusem oprav nahlášené problémy.

Kontrolní seznam před jemným laděním

Projděte si tento seznam v pořadí před vytvořením úlohy – každá položka odpovídá výše pokryté kontrole, kromě poslední, kterou žádný skript nenahradí:

  • Soubor JSONL je syntakticky platný
  • Žádné duplicity
  • Text normalizován (UTF-8, mezery, interpunkce)
  • Systémové zprávy jsou konzistentní
  • Alespoň 50 příkladů (ideálně 100+)
  • Provedeno rozdělení na trénovací a validační sadu
  • Rozumné rozdělení délek
  • Lidská kontrola náhodného vzorku

Klíčové poznatky

  • Vždy validuj syntaxi JSONL před nahráním
  • Odstraň duplicity, abys předešel přeučení
  • Konzistence systémové zprávy je zásadní
  • Zkontroluj rozdělení délek odpovědí
  • Nech člověka zkontrolovat vzorek – je to nenahraditelné