Andmekvaliteet: puhastamine ja valideerimine
Sellel lehel
Uuendus 2. november 2026 — Häälestamise kättesaadavus. OpenAI iseteeninduslik häälestamine kaotatakse järk-järgult: alates 7. maist 2026 ei saa organisatsioonid, mis pole kunagi varem häälestustööd käivitanud, enam uusi luua; alates 2. juulist pead olema häälestatud mudelit kasutanud viimase 60 päeva jooksul; ja alates 6. jaanuarist 2027 ei saa ükski klient uusi töid käivitada. Juba treenitud mudeleid saab kasutada seni, kuni nende baasmudel on kasutuselt kõrvaldatud. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja rakendamiseks; uute projektide puhul seada esikohale vihjeinsenerindus (prompt engineering), RAG ja hindamine.
Miks puhastamine on kriitiline
Tehniliselt korrektne JSONL-fail ei garanteeri head häälestamist. Müraline, ebajärjekindel või halvasti vormindatud andmestik halvendab mudeli jõudlust selle asemel, et seda parandada – ja halvim osa on see, et see ei tekita ühtegi veateadet. Töö lõpeb edukalt, mudel on valmis ja sa avastad probleemi alles tootmiskeskkonnas. See tund käsitleb puhastamise ja valideerimise tehnikaid, mida peaksid läbi viima enne üleslaadimist.
Tehniline faili valideerimine
Alusta mehaanikast: veendu, et su fail on süntaktiliselt korrektne ja et iga rida järgib oodatud lepingut. Allpool olev funktsioon läbib faili realt-realt, kogudes vigu selle asemel, et esimese vea peal peatuda (sa tahad saada täieliku nimekirja, mitte käia iga probleemi pärast edasi-tagasi), ja tagastab samal ajal kasulikku statistikat, nagu süsteemsõnumite ja mitmekäiguliste vestluste olemasolu.
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")
Sisu puhastamine
Täpsed või peaaegu identsed kirjed kallutavad treenimist, esindades teatud mustreid ülemäära. See juhtub loomulikult, kui koondad mitu eksporti: sama sage küsimus ilmub su logides kolmkümmend korda ja mudel järeldab, et see väärib kolmkümmend korda rohkem tähelepanu kui teised. Liidetud sõnumisisu räsi (hash) piisab nende kõrvaldamiseks.
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
Järgmisena tuleb teksti normaliseerimine, mis lahendab neli erinevat probleemi. Mitmed tühikud ja liigsed reavahetused, mis on pärit kopeerimisest, tuleb eemaldada. Kodeering tuleb viia UTF-8 vormingusse, eemaldades juhtmärgid – need on nähtamatud, kuid sageli esinevad andmebaasi eksportides. Kirjavahemärgid vajavad kontrolli: keset lauset katkestatud vastus õpetab mudelit ennast katkestama. Lõpuks veendu keele järjepidevuses – kui soovid viisakat pööramist, kontrolli, et ükski näide ei kasutaks sinatavat vormi, sest mudel kordab seda segu ustavalt.
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()
Järjepidevuse kontrollid
Kui kasutad süsteemsõnumit, peab see olema kõigis su näidetes rangelt identne. Kaks varianti, mis erinevad vaid ühe sõna võrra, piisab signaali lahjendamiseks: mudel lõpetab konkreetse juhise õppimise ja hakkab õppima hägust juhiste perekonda. Kontroll on triviaalne ja tulemus on sageli üllatav mitme inimese koostatud korpuse puhul.
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")
Vastuste pikkuse jaotus räägib sama lugu teise nurga alt. Väga heterogeensed vastused annavad märku, et korpuse on kirjutanud mitu inimest erinevate arusaamadega sellest, kuidas hea vastus välja näeb, või et partiisse on libisenud erand. Siin kasutatud lävi – maksimum, mis on üle viie korra suurem keskmisest – pole absoluutne, kuid see juhib su pilgu õigesse kohta.
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")
OpenAI valideerimis-API kasutamine
Kui oled oma kontrollid läbi viinud, laadi fail üles ja lase ka OpenAI-l see valideerida. See on tasuta, kohene ja hoiab sind avastamast vorminguviga alles siis, kui töö algab.
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}")
Kui fail sisaldab vigu, muutub olek väärtuseks error koos üksikasjaliku sõnumiga. Paranda teatatud probleemid enne uuesti proovimist.
Enne häälestamist tehtav kontrollnimekiri
Käi see nimekiri läbi järjekorras enne töö loomist – iga punkt vastab eespool käsitletud kontrollile, välja arvatud viimane, mida ükski skript asendada ei saa:
- JSONL-fail on süntaktiliselt korrektne
- Duplikaate pole
- Tekst on normaliseeritud (UTF-8, tühikud, kirjavahemärgid)
- Süsteemsõnumid on järjepidevad
- Vähemalt 50 näidet (ideaalis 100+)
- Teostatud on treeningu/valideerimise jagamine
- Pikkuste mõistlik jaotus
- Juhusliku valimi inimlik ülevaatus
Peamised punktid
- Valideeri alati JSONL-i süntaksit enne üleslaadimist
- Eemalda duplikaadid, et vältida ülesobitumist (overfitting)
- Süsteemsõnumi järjepidevus on hädavajalik
- Kontrolli vastuste pikkuse jaotust
- Lase inimesel valimit üle vaadata – seda ei saa asendada