Kvalita dat: čištění a validace
Na této stránce
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é