Calitatea datelor: curățare și validare
Pe această pagină
Actualizare 2 noiembrie 2026 — Disponibilitatea fine-tuning-ului. Serviciul de fine-tuning self-service oferit de OpenAI este în curs de retragere: începând cu 7 mai 2026, organizațiile care nu au rulat niciodată un job de fine-tuning nu mai pot crea unul nou; din 2 iulie, trebuie să fi utilizat un model ajustat (fine-tuned) în ultimele 60 de zile; iar începând cu 6 ianuarie 2027, niciun client nu va mai putea lansa joburi noi. Modelele deja antrenate rămân utilizabile până la retragerea modelului lor de bază. Acest curs rămâne util pentru înțelegerea și exploatarea unui model existent; pentru proiecte noi, prioritizați ingineria prompt-urilor (prompt engineering), RAG și evaluările.
De ce este critică curățarea datelor
Un fișier JSONL valid din punct de vedere tehnic nu garantează un fine-tuning de calitate. Datele zgomotoase, inconsistente sau slab formatate vor degrada performanța modelului în loc să o îmbunătățească, iar partea cea mai gravă este că acest lucru nu va declanșa nicio eroare. Jobul se va finaliza cu succes, modelul va fi gata, iar dumneavoastră veți descoperi problema abia în producție. Această lecție acoperă tehnicile de curățare și validare pe care trebuie să le executați înainte de încărcare.
Validarea tehnică a fișierului
Începeți cu mecanica: verificați dacă fișierul este corect din punct de vedere sintactic și dacă fiecare linie respectă contractul așteptat. Funcția de mai jos parcurge fișierul linie cu linie, acumulând erorile în loc să se oprească la prima întâlnită (doriți lista completă, nu un dus-întors pentru fiecare problemă) și returnează, în același timp, statistici utile, cum ar fi prezența mesajelor de sistem și a conversațiilor multi-tur.
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")
Curățarea conținutului
Intrările duplicate exact sau aproape identice distorsionează antrenamentul prin supra-reprezentarea anumitor tipare. Acest lucru se întâmplă natural atunci când agregați multiple exporturi: aceeași întrebare frecventă apare de treizeci de ori în jurnalele dumneavoastră, iar modelul concluzionează că merită de treizeci de ori mai multă atenție decât altele. Un hash al conținutului concatenat al mesajelor este suficient pentru a le elimina.
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
Urmează normalizarea textului, care abordează patru probleme distincte. Spațiile multiple și rândurile goale superflue, moștenite din copiere-lipește, trebuie eliminate. Codificarea trebuie normalizată la UTF-8, cu caracterele de control eliminate – invizibile, dar adesea prezente în exporturile din bazele de date. Punctuația merită verificată: un răspuns trunchiat la mijloc învață modelul să se întrerupă singur. În final, asigurați consistența limbajului – dacă doriți un ton formal, verificați ca niciun exemplu să nu folosească un ton informal, deoarece modelul va reproduce fidel amestecul.
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()
Verificări de consistență
Dacă utilizați un mesaj de sistem, acesta trebuie să fie riguros identic în toate exemplele dumneavoastră. Două variante care diferă printr-un singur cuvânt sunt suficiente pentru a dilua semnalul: modelul încetează să mai învețe o instrucțiune specifică și începe să învețe o familie vagă de instrucțiuni. Verificarea este trivială, iar rezultatul este adesea surprinzător într-un corpus construit de mai multe persoane.
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")
Distribuția lungimilor răspunsurilor spune aceeași poveste dintr-o altă perspectivă. Răspunsurile extrem de eterogene semnalează faptul că mai multe persoane au scris corpusul cu idei diferite despre cum ar trebui să arate un răspuns bun sau că o valoare aberantă s-a strecurat în lot. Pragul utilizat aici – un maxim de peste cinci ori media – nu este absolut, dar vă atrage atenția asupra locului potrivit.
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")
Utilizarea API-ului de validare OpenAI
După ce ați rulat propriile verificări, încărcați fișierul și lăsați OpenAI să îl valideze, de asemenea. Este gratuit, imediat și vă scutește de descoperirea unei probleme de format atunci când jobul începe.
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}")
Dacă fișierul conține erori, starea se va schimba în error, însoțită de un mesaj detaliat. Remediați problemele raportate înainte de a reîncerca.
Lista de verificare pre-fine-tuning
Parcurgeți această listă în ordine înainte de a crea jobul – fiecare element corespunde unei verificări acoperite mai sus, cu excepția ultimului, pe care niciun script nu îl poate înlocui:
- Fișierul JSONL este valid sintactic
- Fără duplicate
- Text normalizat (UTF-8, spații, punctuație)
- Mesajele de sistem sunt consistente
- Cel puțin 50 de exemple (ideal 100+)
- Separarea train/validation efectuată
- Distribuție rezonabilă a lungimilor
- Revizuire umană a unui eșantion aleatoriu
Puncte cheie
- Validați întotdeauna sintaxa JSONL înainte de încărcare
- Eliminați duplicatele pentru a evita supra-ajustarea (overfitting)
- Consistența mesajului de sistem este esențială
- Verificați distribuția lungimilor răspunsurilor
- Solicitați unei persoane să revizuiască un eșantion – este de neînlocuit