Versionare și Rollback
Pe această pagină
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.
| Versiune | Ce semnalează |
|---|---|
| v1.0 | Primul model validat în producție |
| v1.1 | Corecție de date (aceiași hiperparametri) |
| v2.0 | Schimbare a modelului de bază sau a strategiei |
| v2.1 | Ajustare 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.