Verzionovanie a návrat k predchádzajúcim verziám
Na tejto strane
Aktualizácia 2. novembra 2026 — Dostupnosť jemného doladenia. Služba vlastného jemného doladenia od OpenAI sa postupne ukončuje: od 7. mája 2026 organizácie, ktoré ju nikdy nepoužili, už nemôžu vytvárať nové úlohy; od 2. júla musíte mať použitý jemne doladený model za posledných 60 dní; a od 6. januára 2027 žiadny zákazník nebude môcť spustiť nové úlohy. Už natrénované modely zostávajú použiteľné až do vyradenia ich základného modelu. Tento kurz zostáva užitočný na pochopenie a využitie existujúceho modelu; pre nové projekty uprednostnite inžinierstvo promptov, RAG a evaluácie.
Prečo verzionovať svoje modely
V produkcii budeš iterovať na svojom jemne doladenom modeli: nové dáta, upravené hyperparametre, nový základný model. Bez rigorózneho systému verzionovania stratíš sledovateľnosť a schopnosť vrátiť sa späť v prípade regresie. Scenár je vždy rovnaký: v pondelok ráno sa zhorší spätná väzba od používateľov, nikto nevie, ktorý model je práve spustený ani aké dáta ho vyprodukovali, a tím strávi deň rekonštruovaním informácií, ktoré by zachránil súbor s niekoľkými riadkami.
Pomenovanie verzií
Parameter suffix úlohy jemného doladenia je tvoj prvý nástroj na sledovateľnosť: reťazec, ktorý tam uvedieš, sa objaví v konečnom ID modelu a zostane čitateľný všade – v tvojich logoch, konfigurácii aj konzole. Prijmi konvenciu a drž sa jej.
# Konvencia: {name}-v{major_version}.{minor_version}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Číslo samo o sebe musí niesť informáciu, nielen počítať pokusy. Hlavná verzia sa mení, keď sa zmení povaha modelu; vedľajšia verzia, keď zlepšuješ bez narušenia funkčnosti. Konkrétne, oprava dát aplikovaná s rovnakými hyperparametrami zostáva na tej istej hlavnej verzii, zatiaľ čo zmena základného modelu si vyžaduje začať novú.
| Verzia | Čo signalizuje |
|---|---|
| v1.0 | Prvý model overený v produkcii |
| v1.1 | Oprava dát (rovnaké hyperparametre) |
| v2.0 | Zmena základného modelu alebo stratégie |
| v2.1 | Úprava hyperparametrov |
Udržiavanie registra modelov
Samotný názov nestačí: nič nehovorí o tom, čo bolo v datasete, aké výsledky sa dosiahli ani prečo bola táto verzia povýšená. Centralizovaný register uchováva tieto metadáta popri technickom ID a stáva sa jediným zdrojom pravdy pre tvoj tím. Trieda nižšie uchováva to podstatné v súbore JSON: zaznamená kandidátsky model, povýši jeden do produkcie pričom označí predchádzajúci ako vyradený, vráti aktuálne aktívne ID a zobrazí históriu. Venuj čas vyplneniu poľa notes: jediná veta o tom, čo sa zmenilo oproti predchádzajúcej verzii, ti neskôr ušetrí pol dňa archeológie.
import json
import datetime
class ModelRegistry:
"""Register jemne doladených modelov."""
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 = ""
):
"""Zaznamená nový model do registra."""
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} recorded: {model_id}")
def promote(self, version: str):
"""Povýši model do produkcie."""
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"Production: {old} -> {version}")
def rollback(self, version: str):
"""Návrat k predchádzajúcej verzii."""
self.promote(version)
print(f"Rollback performed to {version}")
def production_model(self) -> str:
"""Vráti ID modelu v produkcii."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Zobrazí históriu modelov."""
print(f"{'Version':<12} {'Status':<12} {'Date':<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)
V praxi sa životný cyklus verzie redukuje na tri volania: zaznamenáš model vychádzajúci z tréningu s jeho číslami, povýšiš ho, keď ho evaluácia potvrdí, a vrátiš sa k predchádzajúcej verzii, ak produkcia odporuje evaluácii. Tento posledný riadok by mal byť rovnako triviálny na napísanie ako prvé dva.
registry = ModelRegistry()
# Zaznamenať nový model
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="Added 50 fix examples for refunds"
)
# Povýšiť do produkcie
registry.promote("v2.1")
# V prípade problémov, návrat späť
registry.rollback("v2.0")
Návrat k predchádzajúcej verzii v sekundách
Návrat k predchádzajúcej verzii má zmysel len vtedy, ak je rýchly a nevyžaduje si premýšľanie. Keďže tvoja aplikácia číta názov modelu z premennej prostredia, zmena verzie znamená zmenu tejto premennej a aktualizáciu registra – žiadne opätovné nasadenie kódu, žiadna rekompilácia. Funkcia quick_rollback ide ešte ďalej tým, že úplne obchádza ľudskú voľbu: vyberie poslednú dostupnú stabilnú verziu a ak žiadna neexistuje, fallbackne na základný model. Táto posledná vetva je tvoja absolútna bezpečnostná sieť; spusti ju dobrovoľne raz v testovacom prostredí, keď sú stávky nulové.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Nasadí model aktualizáciou premennej prostredia."""
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"Version {version} not found")
# Aktualizácia konfigurácie
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Model deployed: {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Návrat k poslednej stabilnej verzii."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Fallback na základný model
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Rollback to base model")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Archivuj dáta, nielen modely
Verzionovanie modelu bez verzionovania toho, čo ho vyprodukovalo, ťa dostane len do polovice cesty. V deň, keď budeš chcieť pochopiť, prečo v2.1 udržala tón lepšie ako v2.2, budeš potrebovať presne tie tri súbory použité na jeho natrénovanie, vrátane testovacej množiny – bez toho nie je žiadne následné porovnanie férové. Archivuj ich do priečinka nesúceho číslo verzie presne v momente, keď zaznamenávaš model.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Archivuje tréningové dáta pre danú verziu."""
folder = f"{archive_folder}/{version}"
os.makedirs(folder, exist_ok=True)
for file in files:
shutil.copy2(file, folder)
print(f"Data archived in {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Automatizuj celý pipeline
Tieto kroky, vykonávané ručne, sa časom vynechávajú – najmä archivácia, ktorá príde ako posledná a nič neblokuje. Zhromaždi ich do jedného skriptu, ktorý reťazí nahratie súborov, spustenie úlohy, čakanie na dokončenie, zaznamenanie do registra a následnú archiváciu dát. Cyklus čakania dopytuje úlohu každých tridsať sekúnd a zastaví sa pri terminálnom stave; v prípade zlyhania funkcia okamžite skončí, namiesto pokračovania s neexistujúcim modelom.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Celý pipeline: upload, train, evaluate, record."""
client = OpenAI()
registry = ModelRegistry()
# 1. Upload
print("Uploading data...")
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. Training
print("Launching 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. Wait for completion
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"Failure: {job.error}")
return None
# 4. Record
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. Archive data
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline complete: {job.fine_tuned_model}")
return job.fine_tuned_model
Upratovanie
Jemne doladené modely sú uložené na OpenAI a môžu byť vymazané, keď ich už nepotrebuješ. Po tucte iterácií sa zoznam stane nečitateľným a manuálne triedenie nebezpečným. Nasledujúce automatické upratovanie ponechá tri najnovšie verzie a nikdy sa nedotkne tej, ktorá beží v produkcii. Vyvaruj sa prílišnej agresivity: práve predposledná verzia, často považovaná za zbytočnú, ťa zachráni počas návratu k predchádzajúcej verzii.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Vymaže staré modely, pričom ponechá posledných 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"Deleted: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Error deleting {m['version']}: {e}")
Kľúčové poznatky
- Používaj verzionované prípony na identifikáciu každého modelu
- Udržiavaj centralizovaný register s metrikami a metadátami
- Implementuj mechanizmus rýchleho návratu k predchádzajúcej verzii
- Archivuj tréningové dáta s každou verziou
- Automatizuj pipeline a pravidelne upratuj staré modely: menej ľudských chýb, menej zbytočných nákladov
Otestuj si svoje vedomosti
Pred verzionovaním svojich modelov over celý cyklus jemného doladenia.
1. Kedy je jemné doladenie správnym nástrojom – a kedy nie?
Odpoveď: Vhodné na ukotvenie štýlu, formátu alebo opakujúceho sa správania, ktoré prompt engineering nedosiahne spoľahlivo; nevhodné na vstrekovanie čerstvých poznatkov – to je úlohou RAG.
2. Čo robí tréningový dataset vysoko kvalitným?
Odpoveď: Čisté, konzistentné a reprezentatívne príklady v konverzačnom formáte JSONL: niekoľko stoviek vynikajúcich príkladov porazí tisíce hlučných.
3. Čo prináša DPO v porovnaní so supervízovaným jemným doladením?
Odpoveď: Učenie preferencií: poskytuješ páry preferovaných/odmietnutých odpovedí a model sa učí „lepšie“ namiesto jednoduchej imitácie – užitočné pre tón a jemné kompromisy.
4. Ako validuješ jemne doladený model?
Odpoveď: Porovnaním so základným modelom na evaluačnej množine oddelenej od tréningu a následne A/B testovaním na obchodných metrikách – nikdy nie len na základe dojmu.
5. Prečo verzionovať a plánovať návrat k predchádzajúcej verzii?
Odpoveď: Každé jemné doladenie produkuje datovaný model: v prípade regresie v produkcii okamžite prepneš späť na predchádzajúcu verziu – s modelom sa zaobchádza ako s kódom.
Čisté dáta, poctivá evaluácia, kontrolované verzie: jemné doladenie je inžinierska disciplína – tento kurz ti dal celý cyklus.