Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Verzioniranje i povrat na prethodnu verziju

Lekcija 16 od 16 Ažurirano 2. studenoga 2026. Napredno
Na ovoj stranici
  1. Zašto verzionirati svoje modele
  2. Imenovanje verzija
  3. Održavanje registra modela
  4. Povrat na prethodnu verziju u sekundama
  5. Arhiviraj podatke, a ne samo modele
  6. Automatiziraj cijeli pipeline
  7. Čišćenje
  8. Ključne točke
  9. Provjeri svoje znanje

Ažuriranje 2. studenoga 2026. — Dostupnost fino podešavanja. OpenAI postupno ukida samostalno fino podešavanje: od 7. svibnja 2026. organizacije koje ga nikada nisu koristile više ne mogu stvarati zadatke; od 2. srpnja morate biti koristili fino podešen model u posljednjih 60 dana; a počevši od 6. siječnja 2027., nijedan korisnik neće moći pokrenuti nove zadatke. Već obučeni modeli ostaju upotrebljivi dok se njihov temeljni model ne povuče. Ovaj tečaj i dalje je koristan za razumijevanje i iskorištavanje postojećeg modela; za nove projekte dajte prednost inženjerstvu upita (prompt engineering), RAG-u i evaluacijama.

Zašto verzionirati svoje modele

U produkciji ćeš iterirati na svom fino podešenom modelu: novi podaci, prilagođeni hiperparametri, novi temeljni model. Bez rigoroznog sustava verzioniranja izgubit ćeš sljedivost i mogućnost povrata na prethodno stanje u slučaju regresije. Scenarij je uvijek isti: ponedjeljak ujutro, povratne informacije korisnika se pogoršavaju, nitko ne zna koji model zapravo radi niti koji su ga podaci proizveli, a tim provodi dan rekonstruirajući informacije koje bi datoteka od nekoliko redaka bila sačuvala.

Imenovanje verzija

Parametar suffix zadatka finog podešavanja tvoj je prvi alat za sljedivost: niz koji tamo uneseš završava u konačnom ID-u modela i ostaje čitljiv svugdje—u tvojim zapisnicima (logovima), konfiguraciji i konzoli. Usvoji konvenciju i drži je se.

# Konvencija: {ime}-v{glavna_verzija}.{sporedna_verzija}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

Sam broj mora nositi informaciju, a ne samo brojati pokušaje. Glavna verzija se mijenja kada se promijeni priroda modela; sporedna verzija kada poboljšavaš bez prekida rada. Konkretno, ispravak podataka primijenjen s istim hiperparametrima ostaje na istoj glavnoj verziji, dok promjena temeljnog modela zahtijeva pokretanje nove.

VerzijaŠto signalizira
v1.0Prvi model validiran u produkciji
v1.1Ispravak podataka (isti hiperparametri)
v2.0Promjena temeljnog modela ili strategije
v2.1Prilagodba hiperparametara

Održavanje registra modela

Samo ime nije dovoljno: ono ne govori ništa o tome što je bilo u skupu podataka, kojih su rezultati postignuti niti zašto je ova verzija promovirana. Centralizirani registar čuva ove metapodatke uz tehnički ID i postaje jedini izvor istine za tvoj tim. Donja klasa čuva bitno u JSON datoteci: bilježi kandidata za model, promovira jedan u produkciju označavajući prethodni kao povučen, vraća trenutno aktivni ID i prikazuje povijest. Odvoji vrijeme za ispunjavanje polja notes: jedna jedina rečenica o tome što se promijenilo od prethodne verzije uštedjet će ti pola dana arheologije kasnije.

import json
import datetime

class ModelRegistry:
    """Registar fino podešenih modela."""

    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 = ""
    ):
        """Bilježi novi model u registar."""
        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):
        """Promovira model u produkciju."""
        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):
        """Povrat na prethodnu verziju."""
        self.promote(version)
        print(f"Rollback performed to {version}")

    def production_model(self) -> str:
        """Vraća ID modela u produkciji."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Prikazuje povijest modela."""
        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)

U praksi se životni ciklus verzije svodi na tri poziva: bilježiš model koji izlazi iz obuke s njegovim brojkama, promoviraš ga kada evaluacija potvrdi njegovu valjanost, i vraćaš se na prethodnu verziju ako produkcija proturječi evaluaciji. Ovaj posljednji redak trebao bi biti jednako trivijalan za napisati kao i prva dva.

registry = ModelRegistry()

# Bilježenje novog modela
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"
)

# Promocija u produkciju
registry.promote("v2.1")

# U slučaju problema, povrat
registry.rollback("v2.0")

Povrat na prethodnu verziju u sekundama

Povrat na prethodnu verziju vrijedi samo ako je brz i ne zahtijeva razmišljanje. Budući da tvoja aplikacija čita ime modela iz varijable okoline, promjena verzije znači promjenu te varijable i ažuriranje registra—bez ponovnog uvođenja koda, bez recompilacije. Funkcija quick_rollback ide korak dalje potpuno zaobilazeći ljudski izbor: ona preuzima posljednju dostupnu stabilnu verziju, a ako nijedna ne postoji, vraća se na temeljni model. Ova posljednja grana tvoja je apsolutna sigurnosna mreža; namjerno je okini jednom u testnom okruženju dok su ulozi nula.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Uvodi model ažuriranjem varijable okoline."""
    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")

    # Ažuriranje konfiguracije
    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):
    """Povrat na posljednju stabilnu verziju."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Povrat na temeljni 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)

Arhiviraj podatke, a ne samo modele

Verzioniranje modela bez verzioniranja onoga što ga je proizvelo odvest će te samo do pola puta. Dan kada budeš htio razumjeti zašto je v2.1 bolje držao ton od v2.2, trebat ćeš točno tri datoteke korištene za njegovu obuku, uključujući testni skup—bez toga nijedna naknadna usporedba nije fer. Arhiviraj ih u mapu koja nosi broj verzije, u trenutku kada bilježiš model.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Arhivira podatke za obuku za danu verziju."""
    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"
)

Automatiziraj cijeli pipeline

Ovi koraci, izvršavani ručno, s vremenom se preskaču—posebno arhiviranje, koje dolazi zadnje i ništa ne blokira. Spoji ih u jednu skriptu koja lančano povezuje učitavanje datoteka, pokretanje zadatka, čekanje na završetak, bilježenje u registar, a zatim arhiviranje podataka. Petlja čekanja ispituje zadatak svakih trideset sekundi i zaustavlja se na terminalnom statusu; u slučaju neuspjeha, funkcija se odmah vraća umjesto da nastavlja s nepostojećim modelom.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Cijeli pipeline: učitavanje, obuka, evaluacija, bilježenje."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Učitavanje
    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. Obuka
    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. Čekanje na završetak
    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. Bilježenje
    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. Arhiviranje podataka
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

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

Čišćenje

Fino podešeni modeli pohranjeni su na OpenAI-u i mogu se izbrisati kada ih više ne trebaš. Nakon desetak iteracija, popis postaje nečitak, a ručno sortiranje opasno. Donje automatsko čišćenje zadržava tri najnovije verzije i nikada ne dira onu koja radi u produkciji. Izbjegavaj biti previše agresivan: upravo je pretposljednja verzija, često smatrana beskorisnom, ta koja će te spasiti tijekom povrata na prethodno stanje.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Briše stare modele zadržavajući zadnjih 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}")

Ključne točke

  • Koristi verzionirane sufikse za identifikaciju svakog modela
  • Održavaj centralizirani registar s metrikama i metapodacima
  • Implementiraj mehanizam brzog povrata na prethodnu verziju
  • Arhiviraj podatke za obuku uz svaku verziju
  • Automatiziraj pipeline i redovito čisti stare modele: manje ljudskih pogrešaka, manje nepotrebnih troškova

Provjeri svoje znanje

Prije verzioniranja svojih modela, validiraj cijeli ciklus finog podešavanja.

1. Kada je fino podešavanje pravi alat—i kada nije?

Odgovor: Dobro za usidravanje stila, formata ili ponavljajućeg ponašanja koje upiti (prompting) ne postižu pouzdano; loše za ubacivanje svježeg znanja—to je uloga RAG-a.

2. Što skup podataka za obuku čini visokokvalitetnim?

Odgovor: Čisti, dosljedni i reprezentativni primjeri u konverzacijskom JSONL formatu: nekoliko stotina izvrsnih primjera vrijedi više od tisuća onih s šumom.

3. Što DPO donosi u usporedbi s nadziranim finim podešavanjem?

Odgovor: Učenje preferencija: pružaš parove preferiranih/odbačenih odgovora, a model uči „bolje“ umjesto jednostavne imitacije—korisno za ton i fine kompromise.

4. Kako validiraš fino podešen model?

Odgovor: Usporedbom s temeljnim modelom na skupu za evaluaciju koji je odvojen od obuke, a zatim A/B testiranjem na poslovnim metrikama—nikada samo na dojmu.

5. Zašto verzionirati i planirati povrat na prethodnu verziju?

Odgovor: Svako fino podešavanje proizvodi datirani model: u slučaju regresije u produkciji, odmah se prebacuješ na prethodnu verziju—modelom se upravlja kao kodom.

Čisti podaci, iskrena evaluacija, kontrolirane verzije: fino podešavanje je inženjerska disciplina—ovaj tečaj dao ti je cijeli ciklus.