Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Verziókezelés és visszagörgetés

16. lecke 16 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. Miért kell verziókezelni a modelleket
  2. Verziók elnevezése
  3. Modelljegyzék karbantartása
  4. Visszagörgetés másodpercek alatt
  5. Az adatok archiválása, nem csak a modelleké
  6. A teljes folyamat automatizálása
  7. Takarítás
  8. Főbb megállapítások
  9. Teszteld a tudásod

Frissítés: 2026. november 2. – Finomhangolás elérhetősége. Az OpenAI saját kiszolgálású finomhangolási szolgáltatását fokozatosan megszüntetik: 2026. május 7. óta azok a szervezetek, amelyek még sosem használták, már nem hozhatnak létre új feladatokat; július 2. óta pedig az elmúlt 60 napban használnod kellett egy finomhangolt modellt; 2027. január 6-tól kezdve pedig egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljüket ki nem vonják. Ez a tanfolyam továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén azonban a prompt mérnökséget, a RAG-ot és az értékeléseket helyezd előtérbe.

Miért kell verziókezelni a modelleket

Éles környezetben folyamatosan iterálni fogsz a finomhangolt modelleden: új adatok, módosított hiperparaméterek, új alapmodell. Szigorú verziókezelési rendszer nélkül elveszíted a nyomon követhetőséget és a visszagörgetés lehetőségét regresszió esetén. A forgatókönyv mindig ugyanaz: hétfő reggel romlik a felhasználói visszajelzés, senki nem tudja, melyik modell fut valójában, vagy milyen adatok hozták létre, és a csapat egész nap olyan információkat próbál rekonstruálni, amelyeket néhány soros fájl megőrzött volna.

Verziók elnevezése

A finomhangolási feladat suffix paramétere az első nyomonkövetési eszközöd: az ide írt karakterlánc bekerül a modell végső azonosítójába, és mindenhol olvasható marad – a naplóidban, a konfigurációdban, a konzolodon. Fogadj el egy konvenciót, és tartsd is magad hozzá.

# Konvenció: {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"
)

Maga a szám információt kell hordozzon, ne csak a próbálkozások számát jelölje. A főverzió (major) akkor változik, ha a modell jellege megváltozik; a mellékverzió (minor) pedig akkor, ha javítasz anélkül, hogy törnél valamit. Konkrétabban: egy adatjavítás ugyanazon hiperparaméterekkel alkalmazva ugyanazon a főverzión marad, míg az alapmodell cseréje új főverzió indítását igényli.

VerzióMit jelez
v1.0Első éles környezetben validált modell
v1.1Adatjavítás (ugyanazon hiperparaméterekkel)
v2.0Alapmodell vagy stratégia váltása
v2.1Hiperparaméter-beállítás

Modelljegyzék karbantartása

Maga a név nem elég: nem árul el semmit az adathalmaz tartalmáról, az elért eredményekről, vagy arról, miért léptették elő ezt a verziót. Egy központosított jegyzék ezeket a metaadatokat tárolja a technikai azonosító mellett, és ez válik a csapatod egyetlen igazságforrásává. Az alábbi osztály egy JSON-fájlban őrzi a lényeget: rögzít egy jelölt modellt, élesbe léptet egyet (miközben az előzőt nyugdíjazottnak jelöli), visszaadja a jelenleg aktív azonosítót, és megjeleníti az előzményeket. Szánj időt a notes mező kitöltésére: egy egyetlen mondat arról, mi változott az előző verzió óta, fél napnyi régészkedést spórol meg neked később.

import json
import datetime

class ModelRegistry:
    """Finomhangolt modellek jegyzéke."""

    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 = ""
    ):
        """Új modell rögzítése a jegyzékben."""
        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):
        """Modell élesbe léptetése."""
        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):
        """Visszagörgetés egy korábbi verzióra."""
        self.promote(version)
        print(f"Rollback performed to {version}")

    def production_model(self) -> str:
        """Visszaadja az éles környezetben lévő modell azonosítóját."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Megjeleníti a modell előzményeit."""
        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)

A gyakorlatban egy verzió életciklusa három hívásra redukálódik: rögzíted a tanításból kikerülő modellt a számaival, élesbe lépteted, amikor az értékelés jóváhagyja, és visszatérsz az előző verzióra, ha az éles környezet ellentmond az értékelésnek. Ez utóbbi sornak ugyanolyan triviálisnak kell lennie leírni, mint az első kettőnek.

registry = ModelRegistry()

# Új modell rögzítése
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"
)

# Élesbe léptetés
registry.promote("v2.1")

# Probléma esetén visszagörgetés
registry.rollback("v2.0")

Visszagörgetés másodpercek alatt

A visszagörgetés csak akkor ér valamit, ha gyors, és nem igényel gondolkodást. Mivel az alkalmazásod egy környezeti változóból olvassa ki a modell nevét, a verzióváltás csupán ennek a változónak a módosítását és a jegyzék frissítését jelenti – nincs szükség kód újratelepítésre vagy újrakompilálásra. A quick_rollback függvény tovább megy azáltal, hogy teljesen megkerüli az emberi döntést: kiválasztja az utolsó elérhető stabil verziót, és ha ilyen nincs, visszaáll az alapmodellre. Ez az utolsó ág a teljes biztonsági hálód; szándékosan indítsd el egyszer egy teszt környezetben, amikor még nulla a tét.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Modell telepítése a környezeti változó frissítésével."""
    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")

    # Konfiguráció frissítése
    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):
    """Visszagörgetés az utolsó stabil verzióra."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Visszaállás az alapmodellre
        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)

Az adatok archiválása, nem csak a modelleké

Egy modell verziókezelése anélkül, hogy kezelnéd azt, ami létrehozta, csak félúton visz el. Amikor meg akarod érteni, miért tartotta jobban a hangnemet a v2.1, mint a v2.2, szükséged lesz arra a pontos három fájlra, amivel betanították, beleértve a teszt készletet is – enélkül egyetlen későbbi összehasonlítás sem tisztességes. Archiváld őket egy, a verziószámot viselő mappában, pontosan abban a pillanatban, amikor rögzíted a modellt.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Betanítási adatok archiválása egy adott verzióhoz."""
    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"
)

A teljes folyamat automatizálása

Ezeket a lépéseket, ha kézzel végzed el, előbb-utóbb kihagyod – különösen az archiválást, ami utoljára jön, és semmit nem blokkol. Gyűjtsd őket egyetlen szkriptbe, amely láncolja a fájlfeltöltést, a feladat indítását, a várakozást a befejezésre, a jegyzékbe rögzítést, majd az adatok archiválását. A várakozási ciklus harminc másodpercenként lekérdezi a feladatot, és leáll egy végleges státusznál; hiba esetén a függvény azonnal visszatér, ahelyett, hogy egy nem létező modellel folytatná.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Teljes folyamat: feltöltés, tanítás, értékelés, rögzítés."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Feltöltés
    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. Tanítás
    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. Várakozás a befejezésre
    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. Rögzítés
    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. Adatok archiválása
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

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

Takarítás

A finomhangolt modellek az OpenAI-n tárolódnak, és törölhetők, amikor már nincs rájuk szükséged. Tucatnyi iteráció után a lista olvashatatlanná válik, a kézi rendezés pedig veszélyes. Az alábbi automatikus takarítás megtartja a három legfrissebb verziót, és soha nem nyúl az éles környezetben futóhoz. Ne legyél túl agresszív: éppen az utolsó előtti verzió, amit gyakran haszontalannak ítélnek, menthet meg egy visszagörgetés során.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Régi modellek törlése, az utolsó N megtartásával."""
    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}")

Főbb megállapítások

  • Használj verziókezelt utótagokat (suffix) az egyes modellek azonosításához
  • Tarts fenn egy központosított jegyzéket metrikákkal és metaadatokkal
  • Implementálj egy gyors visszagörgetési mechanizmust
  • Archiváld a betanítási adatokat minden verzióval együtt
  • Automatizáld a folyamatot, és rendszeresen takarítsd a régi modelleket: kevesebb emberi hiba, kevesebb felesleges költség

Teszteld a tudásod

Mielőtt verziókezeled a modelleidet, validáld a teljes finomhangolási ciklust.

1. Mikor a megfelelő eszköz a finomhangolás – és mikor nem?

Válasz: Jó egy stílus, formátum vagy ismétlődő viselkedés rögzítésére, amit a promptozás nem ér el megbízhatóan; rossz friss ismeretek beillesztésére – erre a RAG való.

2. Mitől lesz magas minőségű egy betanítási adathalmaz?

Válasz: Tiszta, konzisztens és reprezentatív példák beszélgetés formátumú JSONL-ben: néhány száz kiváló példa többet ér ezernyi zajosnál.

3. Mit hoz a DPO a felügyelt finomhangoláshoz képest?

Válasz: Preferencia-tanulást: preferált/elutasított válasz párokat adsz meg, és a modell a „jobbat“ tanulja meg, nem csak az egyszerű utánzást – hasznos a hangnem és a finom kompromisszumok szempontjából.

4. Hogyan validálsz egy finomhangolt modellt?

Válasz: Úgy, hogy összehasonlítod az alapmodellel egy olyan értékelő készleten, amelyet elkülönítve tartottál a tanítástól, majd üzleti metrikákon végzett A/B tesztekkel – soha nem pusztán benyomás alapján.

5. Miért kell verziókezelni és tervezni a visszagörgetést?

Válasz: Minden finomhangolás egy dátumozott modellt hoz létre: regresszió esetén az éles környezetben azonnal visszakapcsolsz az előző verzióra – a modellt úgy kezeled, mint a kódot.

Tiszta adatok, becsületes értékelés, kontrollált verziók: a finomhangolás mérnöki fegyelem – ez a tanfolyam végigvezetett a teljes cikluson.