Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Verzování a návrat k předchozí verzi

Lekce 16 z 16 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Proč verzovat své modely
  2. Pojmenování verzí
  3. Údržba registru modelů
  4. Návrat během vteřin
  5. Archivuj data, nejen modely
  6. Automatizuj celé pipeline
  7. Úklid
  8. Klíčové poznatky
  9. Ověř si své znalosti

Aktualizace 2. listopadu 2026 — Dostupnost jemného ladění. Služba pro vlastní jemné ladění od OpenAI je postupně ukončována: od 7. května 2026 ji organizace, které ji nikdy nepoužily, nemohou nově spustit; od 2. července musíte mít model po jemném ladění použitý alespoň jednou za posledních 60 dní; a počínaje 6. lednem 2027 žádný zákazník nebude moci spustit nové úlohy. Již natrénované modely zůstávají použitelné až do vyřazení jejich základního modelu. Tento kurz je stále užitečný pro pochopení a využití existujícího modelu; u nových projektů dejte přednost inženýrství promptů, RAG a evaluacím.

Proč verzovat své modely

V produkci budeš svůj model po jemném ladění iterativně vylepšovat: nová data, upravené hyperparametry, nový základní model. Bez důsledného systému verzování ztratíš sledovatelnost a možnost návratu k předchozí verzi v případě regrese. Scénář je vždy stejný: v pondělí ráno se zhorší zpětná vazba od uživatelů, nikdo neví, který model právě běží ani jaká data ho vytvořila, a tým stráví celý den rekonstrukcí informací, které by zachránil soubor o několika řádcích.

Pojmenování verzí

Parametr suffix úlohy jemného ladění je tvým prvním nástrojem pro sledovatelnost: řetězec, který tam umístíš, skončí v konečném ID modelu a zůstane čitelný všude – v logách, konfiguraci i konzoli. Přijmi konvenci a drž se jí.

# Konvence: {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 sobě musí nést informaci, nejen počítat pokusy. Hlavní verze se mění, když se změní povaha modelu; vedlejší verze, když něco vylepšíš bez narušení funkčnosti. Konkrétně: oprava dat při stejných hyperparametrech zůstává ve stejné hlavní verzi, zatímco změna základního modelu vyžaduje začít novou.

VerzeCo signalizuje
v1.0První model ověřený v produkci
v1.1Oprava dat (stejné hyperparametry)
v2.0Změna základního modelu nebo strategie
v2.1Úprava hyperparametrů

Údržba registru modelů

Samotný název nestačí: nic neříká o tom, co bylo v datasetu, jaké výsledky byly dosaženy ani proč byla tato verze povýšena. Centralizovaný registr uchovává tato metadata vedle technického ID a stává se jediným zdrojem pravdy pro tvůj tým. Níže uvedená třída udržuje to podstatné v souboru JSON: zaznamená kandidátský model, povýší jeden do produkce (přičemž předchozí označí jako vyřazený), vrátí ID právě aktivního modelu a zobrazí historii. Věnuj čas vyplnění pole notes: jediná věta o tom, co se změnilo oproti předchozí verzi, ti později ušetří půl dne archeologického výzkumu.

import json
import datetime

class ModelRegistry:
    """Registr modelů po jemném ladění."""

    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 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} recorded: {model_id}")

    def promote(self, version: str):
        """Povýší model do produkce."""
        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 předchozí verzi."""
        self.promote(version)
        print(f"Rollback performed to {version}")

    def production_model(self) -> str:
        """Vrátí ID modelu v produkci."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Zobrazí historii modelů."""
        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 se životní cyklus verze redukuje na tři volání: zaznamenáš model vycházející z tréninku s jeho čísly, povýšíš ho, když ho evaluace potvrdí, a vrátíš se k předchozí verzi, pokud produkce odporuje evaluaci. Tento poslední řádek by měl být stejně triviální k napsání jako ty první dva.

registry = ModelRegistry()

# Zaznamenat 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ýšit do produkce
registry.promote("v2.1")

# V případě problémů návrat
registry.rollback("v2.0")

Návrat během vteřin

Návrat k předchozí verzi má smysl pouze tehdy, když je rychlý a nevyžaduje přemýšlení. Protože tvoje aplikace čte název modelu z proměnné prostředí, změna verze znamená změnu této proměnné a aktualizaci registru – žádné nové nasazení kódu, žádná recompilace. Funkce quick_rollback jde ještě dál a zcela obchází lidskou volbu: vybere poslední dostupnou stabilní verzi a pokud žádná není, fallbackne na základní model. Tato poslední větev je tvou absolutní bezpečnostní sítí; spusť ji dobrovolně alespoň jednou v testovacím prostředí, dokud jsou sázky nulové.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Nasadí model aktualizací proměnné prostředí."""
    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")

    # Aktualizace konfigurace
    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 poslední stabilní verzi."""
    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 data, nejen modely

Verzování modelu bez verzování toho, co ho vytvořilo, tě dostane jen do poloviny cesty. Až budeš chtít pochopit, proč si v2.1 udržel tón lépe než v2.2, budeš potřebovat přesně ty tři soubory, které byly použity k jeho tréninku, včetně testovací sady – bez ní žádné následné srovnání není férové. Archivuj je do složky nesoucí číslo verze, a to přesně v okamžiku, kdy model zaznamenáváš.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Archivuje tréninková data pro danou verzi."""
    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

Tyto kroky, pokud jsou prováděny ručně, se časem začnou vynechávat – zejména archivace, která přichází jako poslední a nic neblokuje. Shromáždi je do jediného skriptu, který řetězí nahrání souborů, spuštění úlohy, čekání na dokončení, zaznamenání do registru a následně archivaci dat. Smyčka čekání dotazuje úlohu každých třicet sekund a zastaví se při koncovém stavu; v případě selhání funkce okamžitě skončí, místo aby pokračovala s neexistujícím modelem.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Kompletní pipeline: upload, trénink, evaluace, záznam."""
    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. Trénink
    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. Čekání na dokončení
    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. Záznam
    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. Archivace dat
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

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

Úklid

Modely po jemném ladění jsou uloženy na OpenAI a lze je smazat, když je již nepotřebuješ. Po tuctu iterací se seznam stane nečitelným a ruční třídění nebezpečným. Níže uvedený automatický úklid ponechá tři nejnovější verze a nikdy se nedotkne té, která běží v produkci. Vyvaruj se přílišné agresivity: právě předposlední verze, často považovaná za zbytečnou, tě zachrání při návratu.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Smaže staré modely a 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}")

Klíčové poznatky

  • Používej verzované suffixy k identifikaci každého modelu
  • Udržuj centralizovaný registr s metrikami a metadaty
  • Implementuj mechanismus rychlého návratu
  • Archivuj tréninková data u každé verze
  • Automatizuj pipeline a pravidelně čistí staré modely: méně lidských chyb, méně zbytečných nákladů

Ověř si své znalosti

Než začneš verzovat své modely, ověř si celý cyklus jemného ladění.

1. Kdy je jemné ladění správným nástrojem – a kdy není?

Odpověď: Vhodné pro ukotvení stylu, formátu nebo opakujícího se chování, kterého promptování nedosáhne spolehlivě; nevhodné pro vkládání čerstvých znalostí – to je role RAG.

2. Co dělá tréninkový dataset vysoce kvalitním?

Odpověď: Čisté, konzistentní a reprezentativní příklady v konverzačním formátu JSONL: několik stovek vynikajících příkladů porazí tisíce těch zašuměných.

3. Co přináší DOP ve srovnání se supervizovaným jemným laděním?

Odpověď: Učení z preferencí: poskytuješ páry preferovaných/odmítnutých odpovědí a model se učí „lépe“ než pouhou imitaci – užitečné pro tón a jemné kompromisy.

4. Jak ověříš model po jemném ladění?

Odpověď: Porovnáním se základním modelem na evaluační sadě oddělené od tréninku a následně A/B testováním na obchodních metrikách – nikdy pouze na základě dojmu.

5. Proč verzovat a plánovat návrat?

Odpověď: Každé jemné ladění vytvoří datovaný model: v případě regrese v produkci okamžitě přepneš na předchozí verzi – s modelem se zachází jako s kódem.

Čistá data, poctivá evaluace, kontrolované verze: jemné ladění je inženýrská disciplína – tento kurz ti dal celý cyklus.