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

Versionare și Rollback

Lecția 16 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. De ce să vă versionați modelele
  2. Denumirea versiunilor
  3. Menținerea unui registru de modele
  4. Rollback în câteva secunde
  5. Arhivați datele, nu doar modelele
  6. Automatizarea întregului pipeline
  7. Curățare
  8. Puncte cheie
  9. Testați-vă cunoștințele

Actualizare 2 noiembrie 2026 — Disponibilitatea fine-tuning. Soluția de fine-tuning self-service de la OpenAI este în curs de retragere: începând cu 7 mai 2026, organizațiile care nu au utilizat-o niciodată nu mai pot crea job-uri; începând cu 2 iulie, trebuie să fi utilizat un model fine-tuned în ultimele 60 de zile; iar începând cu 6 ianuarie 2027, niciun client nu va mai putea lansa job-uri 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, RAG și evaluările.

De ce să vă versionați modelele

În producție, veți itera asupra modelului dumneavoastră fine-tuned: date noi, hiperparametri ajustați, model de bază nou. Fără un sistem riguros de versionare, veți pierde trasabilitatea și capacitatea de a reveni la o versiune anterioară (rollback) în caz de regresie. Scenariul este mereu același: într-o dimineață de luni, feedback-ul utilizatorilor se deteriorează, nimeni nu știe ce model rulează de fapt sau ce date l-au produs, iar echipa își petrece ziua reconstruind informații pe care un fișier de câteva linii le-ar fi conservat.

Denumirea versiunilor

Parametrul suffix al job-ului de fine-tuning este primul dumneavoastră instrument de trasabilitate: șirul pe care îl plasați acolo ajunge în ID-ul final al modelului și rămâne lizibil peste tot—în jurnalele dumneavoastră, în configurație, în consolă. Adoptați o convenție și respectați-o.

# Convenție: {nume}-v{versiune_majoră}.{versiune_minoră}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

Numărul în sine trebuie să poarte informație, nu doar să numere încercările. O versiune majoră se schimbă atunci când natura modelului se modifică; o versiune minoră, atunci când îmbunătățiți fără a strica funcționalitatea existentă. Concret, o corecție de date aplicată cu aceiași hiperparametri rămâne la aceeași versiune majoră, în timp ce o schimbare a modelului de bază necesită începerea uneia noi.

VersiuneCe semnalează
v1.0Primul model validat în producție
v1.1Corecție de date (aceiași hiperparametri)
v2.0Schimbare a modelului de bază sau a strategiei
v2.1Ajustare a hiperparametrilor

Menținerea unui registru de modele

Numele singur nu este suficient: nu spune nimic despre conținutul setului de date, rezultatele obținute sau motivul pentru care această versiune a fost promovată. Un registru centralizat păstrează aceste metadate alături de ID-ul tehnic și devine singura sursă de adevăr pentru echipa dumneavoastră. Clasa de mai jos păstrează esențialul într-un fișier JSON: înregistrează un model candidat, promovează unul în producție marcându-l pe cel anterior ca retras, returnează ID-ul activ curent și afișează istoricul. Luați-vă timp pentru a completa câmpul notes: o singură propoziție despre ce s-a schimbat față de versiunea anterioară vă va economisi o jumătate de zi de arheologie mai târziu.

import json
import datetime

class ModelRegistry:
    """Registru de modele fine-tuned."""

    def __init__(self, path: str = "model_registry.json"):
        self.path = path
        try:
            with open(path, "r") as f:
                self.registry = json.load(f)
        except FileNotFoundError:
            self.registry = {"models": [], "production": None}

    def record(
        self,
        version: str,
        model_id: str,
        job_id: str,
        dataset_info: dict,
        hyperparams: dict,
        metrics: dict,
        notes: str = ""
    ):
        """Înregistrează un model nou în registru."""
        entry = {
            "version": version,
            "model_id": model_id,
            "job_id": job_id,
            "date": datetime.datetime.now().isoformat(),
            "dataset": dataset_info,
            "hyperparameters": hyperparams,
            "metrics": metrics,
            "notes": notes,
            "status": "candidate"
        }
        self.registry["models"].append(entry)
        self._save()
        print(f"Model {version} înregistrat: {model_id}")

    def promote(self, version: str):
        """Promovează un model în producție."""
        old = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                m["status"] = "production"
                self.registry["production"] = version
                break

        if old:
            for m in self.registry["models"]:
                if m["version"] == old:
                    m["status"] = "retired"

        self._save()
        print(f"Producție: {old} -> {version}")

    def rollback(self, version: str):
        """Rollback la o versiune anterioară."""
        self.promote(version)
        print(f"Rollback efectuat la {version}")

    def production_model(self) -> str:
        """Returnează ID-ul modelului în producție."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Afișează istoricul modelelor."""
        print(f"{'Versiune':<12} {'Status':<12} {'Dată':<12} {'Val Loss':<10}")
        print("-" * 50)
        for m in self.registry["models"]:
            date = m["date"][:10]
            loss = m["metrics"].get("validation_loss", "N/A")
            print(f"{m['version']:<12} {m['status']:<12} {date:<12} {loss}")

    def _save(self):
        with open(self.path, "w") as f:
            json.dump(self.registry, f, indent=2, ensure_ascii=False)

În practică, ciclul de viață al unei versiuni se reduce la trei apeluri: înregistrați modelul ieșit din antrenament cu cifrele sale, îl promovați când evaluarea îl validează și reveniți la versiunea anterioară dacă producția contrazice evaluarea. Această ultimă linie ar trebui să fie la fel de trivial de scris ca primele două.

registry = ModelRegistry()

# Înregistrarea unui model nou
registry.record(
    version="v2.1",
    model_id="ft:gpt-5.6-luna:org::support-v2.1:abc123",
    job_id="ftjob-xyz789",
    dataset_info={"train": 350, "validation": 45},
    hyperparams={"n_epochs": 3, "lr": "auto"},
    metrics={"validation_loss": 0.38, "precision_test": 0.93},
    notes="Adăugate 50 de exemple de corecție pentru rambursări"
)

# Promovare în producție
registry.promote("v2.1")

# În caz de probleme, rollback
registry.rollback("v2.0")

Rollback în câteva secunde

Un rollback are valoare doar dacă este rapid și nu necesită ezitare. Deoarece aplicația dumneavoastră citește numele modelului dintr-o variabilă de mediu, schimbarea versiunilor înseamnă schimbarea acelei variabile și actualizarea registrului—fără redeployare de cod, fără recompilare. Funcția quick_rollback merge mai departe, ocolind complet alegerea umană: preia ultima versiune stabilă disponibilă și, dacă nu există niciuna, revine la modelul de bază. Această ultimă ramură este plasa dumneavoastră de siguranță absolută; declanșați-o voluntar o dată într-un mediu de test, cât timp miza este zero.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Deployează un model prin actualizarea variabilei de mediu."""
    model_id = None
    for m in registry.registry["models"]:
        if m["version"] == version:
            model_id = m["model_id"]
            break

    if not model_id:
        raise ValueError(f"Versiunea {version} nu a fost găsită")

    # Actualizare configurație
    os.environ["OPENAI_FT_MODEL"] = model_id
    registry.promote(version)

    print(f"Model deployat: {version} ({model_id})")
    return model_id

def quick_rollback(registry: ModelRegistry):
    """Rollback la ultima versiune stabilă."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Fallback la modelul de bază
        os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
        print("Rollback la modelul de bază")
        return

    last_stable = versions[-1]
    deploy_model(last_stable["version"], registry)

Arhivați datele, nu doar modelele

Versionarea unui model fără versionarea a ceea ce l-a produs vă duce doar pe jumătate din drum. În ziua în care veți dori să înțelegeți de ce v2.1 a menținut tonul mai bine decât v2.2, veți avea nevoie de exact cele trei fișiere utilizate pentru antrenamentul său, inclusiv setul de test—fără acesta, nicio comparație ulterioară nu este corectă. Arhivați-le într-un folder purtând numărul versiunii, chiar în momentul în care înregistrați modelul.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Arhivează datele de antrenament pentru o versiune dată."""
    folder = f"{archive_folder}/{version}"
    os.makedirs(folder, exist_ok=True)

    for file in files:
        shutil.copy2(file, folder)

    print(f"Date arhivate în {folder}")

archive_dataset(
    "v2.1",
    ["train.jsonl", "validation.jsonl", "test.jsonl"],
    "archives/datasets"
)

Automatizarea întregului pipeline

Acești pași, executați manual, ajung în cele din urmă să fie omiși—în special arhivarea, care vine la final și nu blochează nimic. Grupați-i într-un singur script care înlănțuie încărcarea fișierelor, lansarea job-ului, așteptarea finalizării, înregistrarea în registru și apoi arhivarea datelor. Bucla de așteptare interoghează job-ul la fiecare treizeci de secunde și se oprește la un status terminal; în caz de eșec, funcția returnează imediat, în loc să continue cu un model inexistent.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Pipeline complet: upload, antrenament, evaluare, înregistrare."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Upload
    print("Încărcare date...")
    train = client.files.create(file=open(training_file, "rb"), purpose="fine-tune")
    val = client.files.create(file=open(validation_file, "rb"), purpose="fine-tune")

    # 2. Antrenament
    print("Lansare fine-tuning...")
    params = {"training_file": train.id, "validation_file": val.id,
              "model": base_model, "suffix": version}
    if hyperparams:
        params["hyperparameters"] = hyperparams

    job = client.fine_tuning.jobs.create(**params)

    # 3. Așteptare finalizare
    import time
    while True:
        job = client.fine_tuning.jobs.retrieve(job.id)
        if job.status in ("succeeded", "failed"):
            break
        time.sleep(30)

    if job.status == "failed":
        print(f"Eșec: {job.error}")
        return None

    # 4. Înregistrare
    registry.record(
        version=version,
        model_id=job.fine_tuned_model,
        job_id=job.id,
        dataset_info={"train": training_file, "validation": validation_file},
        hyperparams=hyperparams or {},
        metrics={"trained_tokens": job.trained_tokens}
    )

    # 5. Arhivare date
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

    print(f"Pipeline complet: {job.fine_tuned_model}")
    return job.fine_tuned_model

Curățare

Modelele fine-tuned sunt stocate la OpenAI și pot fi șterse când nu mai aveți nevoie de ele. După o duzină de iterații, lista devine ilizibilă, iar sortarea manuală periculoasă. Curățarea automată de mai jos păstrează cele mai recente trei versiuni și nu atinge niciodată cea care rulează în producție. Evitați să fiți prea agresivi: este chiar versiunea penultimă, adesea considerată inutilă, cea care vă va salva în timpul unui rollback.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Șterge modelele vechi păstrându-le pe ultimele N."""
    models = registry.registry["models"]
    production = registry.registry["production"]

    candidates = [
        m for m in models
        if m["version"] != production
    ]

    to_delete = candidates[:-keep] if len(candidates) > keep else []

    for m in to_delete:
        try:
            client.models.delete(m["model_id"])
            print(f"Șters: {m['version']} ({m['model_id']})")
        except Exception as e:
            print(f"Eroare la ștergerea {m['version']}: {e}")

Puncte cheie

  • Utilizați sufixe versionate pentru a identifica fiecare model
  • Mențineți un registru centralizat cu metrici și metadate
  • Implementați un mecanism de rollback rapid
  • Arhivați datele de antrenament pentru fiecare versiune
  • Automatizați pipeline-ul și curățați regulat modelele vechi: mai puține erori umane, mai puține costuri inutile

Testați-vă cunoștințele

Înainte de a vă versiona modelele, validați ciclul complet de fine-tuning.

1. Când este fine-tuning-ul instrumentul potrivit—și când nu?

Răspuns: Bun pentru ancorarea unui stil, format sau comportament recurent pe care prompt-ingul nu îl obține fiabil; rău pentru injectarea de cunoștințe proaspete—acela este rolul RAG.

2. Ce face ca un set de date de antrenament să fie de înaltă calitate?

Răspuns: Exemple curate, consistente și reprezentative în format JSONL conversațional: câteva sute de exemple excelente bat mii de exemple zgomotoase.

3. Ce aduce DPO comparativ cu fine-tuning-ul supervizat?

Răspuns: Învățarea preferințelor: furnizați perechi de răspunsuri preferate/respinse, iar modelul învață „mai bine“ decât simpla imitație—util pentru ton și compromisuri fine.

4. Cum validați un model fine-tuned?

Răspuns: Comparându-l cu modelul de bază pe un set de evaluare ținut separat de antrenament, apoi prin testare A/B pe metrici de business—niciodată doar pe impresie.

5. De ce să versionați și să planificați rollback?

Răspuns: Fiecare fine-tuning produce un model datat: în caz de regresie în producție, reveniți imediat la versiunea anterioară—modelul este gestionat ca și codul.

Date curate, evaluare onestă, versiuni controlate: fine-tuning-ul este o disciplină de inginerie—acest curs v-a oferit ciclul complet.