Iterație: Când să reantrenați modelul
Pe această pagină
Actualizare 2 noiembrie 2026 — Disponibilitatea fine-tuning-ului. Funcționalitatea de auto-serviciu pentru fine-tuning de la OpenAI este în curs de eliminare: începând cu 7 mai 2026, organizațiile care nu au rulat niciodată un job de fine-tuning nu mai pot crea unul; începând cu 2 iulie, trebuie să fi utilizat un model ajustat î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 prompturilor, RAG și evaluările.
Fine-tuning-ul este un proces iterativ
Prima dvs. rulare de fine-tuning va fi rareori perfectă. Îmbunătățirea provine din cicluri iterative: analizați erorile, îmbogățiți datele, reantrenați și reevaluați. Această lecție vă învață cum să identificați când și cum să iterați eficient și, la fel de important, cum să recunoașteți situațiile în care reantrenarea ar fi inutilă.
Analizați erorile înainte de a le remedia
Reflexul natural după o evaluare dezamăgitoare este să adăugați exemple la întâmplare, sperând că volumul va rezolva problema. Aceasta este cea mai rapidă metodă de a vă epuiza bugetul de antrenament fără a face progrese. Începeți prin a sorta fiecare eșec într-o categorie: formatare incorectă, ton nepotrivit, eroare factuală, răspuns incomplet, răspuns în afara subiectului sau halucinație pură. Distribuția rezultată vă indică unde să vă concentrați eforturile și dezvăluie adesea o surpriză – ceea ce credeați că este o problemă de stil se dovedește a fi o problemă de completitudine.
def analyze_errors(results: list[dict]) -> dict:
"""Categorizes errors from the fine-tuned model."""
categories = {
"format": [], # Incorrect response format
"tone": [], # Inappropriate tone
"factual": [], # Incorrect information
"incomplete": [], # Response too short or missing elements
"off_topic": [], # Does not answer the question
"hallucination": [] # Invents information
}
for r in results:
if r.get("score", 5) < 3:
# Classify the error (can be done manually or by an LLM)
category = classify_error(r)
categories[category].append(r)
print("Error distribution:")
for cat, errors in categories.items():
if errors:
print(f" {cat}: {len(errors)} cases")
return categories
În continuare, examinați cazurile din aceeași categorie pentru a găsi un numitor comun. Puneți-vă mereu aceleași întrebări: eșuează modelul la un anumit tip de întrebare, se grupează erorile în jurul unor anumite subiecte și provine problema din date sau din hiperparametri? Eșecurile împrăștiate pe toate subiectele, dar mereu de aceeași natură, indică o lipsă de exemple; eșecurile concentrate într-un singur domeniu indică o lacună de acoperire; iar răspunsurile care se lipesc prea mult de exemplele de antrenament, indiferent de întrebare, semnalează un overfitting care necesită corectare la nivelul epocilor.
Recunoașterea momentului potrivit pentru iterare
Anumite semnale solicită fără echivoc o nouă versiune, iar fiecare necesită un răspuns diferit. Un model care halucinează asupra unui subiect nu se repară arătându-i mai multe răspunsuri corecte despre acel subiect, ci învățându-l să refuze politicos atunci când nu știe.
| Semnal | Acțiune |
|---|---|
| Erori recurente de formatare | Adăugați mai multe exemple cu formatul corect |
| Modelul halucinează pe anumite subiecte | Adăugați exemple în care refuză politicos |
| Overfitting detectat | Reduceți epocile, diversificați datele |
| Noi cazuri de utilizare de acoperit | Adăugați exemple pentru aceste cazuri |
| Feedback negativ specific de la utilizatori | Transformați feedback-ul în exemple corectate |
Dimpotrivă, există câteva situații care ar trebui să vă oprească din reantrenare. Când erorile sunt rare și nesistematice, o ajustare a promptului le gestionează mai rapid și mai ieftin. Când plângerile vizează latența sau timpii de așteptare, problema reside în infrastructura dvs., iar niciun amount de antrenament nu o va rezolva. Când ați colectat doar câteva exemple noi de la ultima versiune, câștigul estimat nu va acoperi costul rulării. Iar când devine disponibil un nou model de bază, testați-l mai întâi așa cum este: uneori realizează singur, fără antrenament, ceea ce versiunea dvs. anterioară abia reușea să livreze.
Îmbogățiți, nu începeți de la zero
Iterația incrementală înseamnă adăugarea de exemple țintite la un set de date existent fără a atinge restul. Aceasta este operațiunea cea mai frecventă și mai simplă: încărcați fișierul curent, concatenați noile cazuri și rescrieți totul în format JSONL. Numărul final servește drept control – un total care nu corespunde sumei așteptate indică o eroare de citire a fișierului sau linii pierdute.
import json
def enrich_dataset(
existing_dataset: str,
new_examples: list[dict],
output: str
):
"""Adds new examples to the existing dataset."""
# Load existing data
with open(existing_dataset, "r") as f:
existing = [json.loads(l) for l in f]
# Merge
combined = existing + new_examples
# Save
with open(output, "w") as f:
for ex in combined:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"Enriched dataset: {len(existing)} + {len(new_examples)} = {len(combined)}")
Iterația corectivă este și mai valoroasă, deoarece transformă eșecurile dvs. în materie primă. Fiecare eroare observată în producție oferă o întrebare reală; trebuie doar să scrieți răspunsul pe care ați fi dorit să-l vedeți, iar perechea devine un exemplu de antrenament. Rețineți că răspunsul greșit nu intră în exemplul final: acesta ajută la documentarea cazului și la deciderea dacă corecția merită efortul, dar modelul învață doar din versiunea corectă.
def error_to_example(
question: str,
bad_response: str,
good_response: str,
system_msg: str
) -> dict:
"""Transforms an error into a training example."""
return {
"messages": [
{"role": "system", "content": system_msg},
{"role": "user", "content": question},
{"role": "assistant", "content": good_response}
]
}
# Transform a batch of errors
corrections = []
for error in detected_errors:
correction = error_to_example(
question=error["question"],
bad_response=error["model_response"],
good_response=error["corrected_response"],
system_msg=SYSTEM_PROMPT
)
corrections.append(correction)
Fine-tuning continuu și limitele sale
Nimic nu vă împiedică să faceți fine-tuning unui model deja ajustat: transmiteți doar ID-ul său complet în parametrul model în loc de numele modelului de bază. Operațiunea este tentantă deoarece antrenează doar pe noile date.
# Fine-tune from an already fine-tuned model
job_v2 = client.fine_tuning.jobs.create(
training_file=new_file.id,
model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx", # v1 model as base
suffix="my-assistant-v2"
)
Avertisment: fine-tuning-ul continuu acumulează bias-uri. După 2–3 iterații successive, este adesea mai bine să o luați de la capăt de la modelul de bază cu un set de date complet și îmbogățit. Fiecare strat amplifică particularitățile celui anterior, inclusiv pe cele pe care nu le-ați intenționat, iar modelul ajunge să răspundă cu o rigiditate pe care nimeni nu i-a predat-o explicit.
Ciclul complet
Pașii de mai jos formează bucla pe care o veți repeta pentru fiecare versiune. Dacă abordați mai întâi erorile cele mai frecvente, următoarea versiune va arăta câștiguri măsurabile pe setul de test; abordarea lor într-o ordine aleatorie yieldă doar o îmbunătățire difuză, greu de apărat în fața echipei dvs.
Colectați erorile
Identificați cazurile în care modelul eșuează în producție sau în timpul evaluării.
Categorizați și prioritizați
Clasificați erorile pe tipuri și abordați-le mai întâi pe cele mai frecvente.
Creați exemple corective
Transformați fiecare eroare într-un exemplu de antrenament cu răspunsul corect.
Reantrenați și reevaluați
Antrenați noua versiune și comparați-o cu cea anterioară pe același set de test.
Documentați fiecare iterație
După patru sau cinci versiuni, nimeni nu-și mai amintește ce distingea v2 de v3 sau de ce a fost abandonat v4. Înregistrarea sistematică a fiecărei rulări – compoziția setului de date, sursa noilor exemple, hiperparametrii, rezultatele și decizia luată – vă oferă aceste informații atunci când o regresie vă obligă să retrageți pașii. Acordați o atenție deosebită sursei noilor exemple: doar aceasta vă va spune, luni mai târziu, dacă degradarea a provenit dintr-un lot de date ales necorespunzător.
iteration_log = {
"version": "v3",
"date": "2026-04-02",
"base_model": "gpt-5.6-luna",
"dataset": {
"train": 350,
"validation": 45,
"new_examples": 50,
"new_examples_source": "production errors week 12"
},
"hyperparameters": {
"n_epochs": 3,
"learning_rate_multiplier": "auto",
"batch_size": "auto"
},
"results": {
"validation_loss": 0.42,
"precision_test": 0.91,
"avg_csat": 4.3,
"improvement_vs_v2": "+5% precision, +0.2 CSAT"
},
"decision": "Deployed to production on 2026-04-03"
}
Puncte cheie
- Fine-tuning-ul este iterativ – planificați multiple cicluri
- Categorizați erorile înainte de a le corecta în date
- Transformați feedback-ul utilizatorilor în exemple de antrenament
- După 2–3 iterații successive, reporniți de la modelul de bază
- Documentați fiecare iterație pentru a menține un istoric clar