Salt la conținutul principal
Română— Alege o limbă
Meniu

Iterație: Când să reantrenați modelul

Lecția 13 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. Fine-tuning-ul este un proces iterativ
  2. Analizați erorile înainte de a le remedia
  3. Recunoașterea momentului potrivit pentru iterare
  4. Îmbogățiți, nu începeți de la zero
  5. Fine-tuning continuu și limitele sale
  6. Ciclul complet
  7. Documentați fiecare iterație
  8. Puncte cheie

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.

SemnalAcțiune
Erori recurente de formatareAdăugați mai multe exemple cu formatul corect
Modelul halucinează pe anumite subiecteAdăugați exemple în care refuză politicos
Overfitting detectatReduceți epocile, diversificați datele
Noi cazuri de utilizare de acoperitAdăugați exemple pentru aceste cazuri
Feedback negativ specific de la utilizatoriTransformaț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.

1

Colectați erorile

Identificați cazurile în care modelul eșuează în producție sau în timpul evaluării.

2

Categorizați și prioritizați

Clasificați erorile pe tipuri și abordați-le mai întâi pe cele mai frecvente.

3

Creați exemple corective

Transformați fiecare eroare într-un exemplu de antrenament cu răspunsul corect.

4

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