Verziókezelés és visszagörgetés
Ezen az oldalon
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.0 | Első éles környezetben validált modell |
| v1.1 | Adatjavítás (ugyanazon hiperparaméterekkel) |
| v2.0 | Alapmodell vagy stratégia váltása |
| v2.1 | Hiperparamé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.