Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Verzionovanie a návrat k predchádzajúcim verziám

Lekcia 16 z 16 Aktualizované 2. novembra 2026 Pokročilý
Na tejto strane
  1. Prečo verzionovať svoje modely
  2. Pomenovanie verzií
  3. Udržiavanie registra modelov
  4. Návrat k predchádzajúcej verzii v sekundách
  5. Archivuj dáta, nielen modely
  6. Automatizuj celý pipeline
  7. Upratovanie
  8. Kľúčové poznatky
  9. Otestuj si svoje vedomosti

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.0Prvý model overený v produkcii
v1.1Oprava dát (rovnaké hyperparametre)
v2.0Zmena 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.