Versioning en Rollback
Op deze pagina
Update 2 november 2026 — Beschikbaarheid fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd uitgefaseerd: sinds 7 mei 2026 kunnen organisaties die het nooit hebben gebruikt geen jobs meer aanmaken; sinds 2 juli moet u binnen de laatste 60 dagen een fine-tuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe jobs starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.
Waarom u modellen moet versioneren
In productie zult u itereren op uw fine-tuned model: nieuwe data, aangepaste hyperparameters, een nieuw basismodel. Zonder een rigoureus versioneringssysteem verliest u de traceerbaarheid en het vermogen om terug te draaien bij regressie. Het scenario is altijd hetzelfde: op een maandagochtend verslechtert de gebruikersfeedback, niemand weet welk model er daadwerkelijk draait of welke data het heeft geproduceerd, en het team spendeert de dag aan het reconstrueren van informatie die een bestand van een paar regels had kunnen bewaren.
Versies benoemen
De parameter suffix van de fine-tuning job is uw eerste instrument voor traceerbaarheid: de string die u daar plaatst, eindigt in de uiteindelijke ID van het model en blijft overal leesbaar—in uw logs, uw configuratie, uw console. Hanteer een conventie en houd u eraan.
# Conventie: {naam}-v{hoofd_versie}.{kleine_versie}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Het nummer zelf moet informatie dragen, niet alleen pogingen tellen. Een hoofdversie verandert wanneer de aard van het model verandert; een kleine versie wanneer u verbetert zonder iets te breken. Concreet: een data-fix toegepast met dezelfde hyperparameters blijft op dezelfde hoofdversie, terwijl een wijziging van het basismodel vereist dat u een nieuwe start.
| Versie | Wat het signaleert |
|---|---|
| v1.0 | Eerste model gevalideerd in productie |
| v1.1 | Data-fix (zelfde hyperparameters) |
| v2.0 | Wijziging van basismodel of strategie |
| v2.1 | Aanpassing hyperparameters |
Een modelregister onderhouden
De naam alleen is niet genoeg: deze zegt niets over wat er in de dataset zat, welke resultaten werden behaald, of waarom deze versie werd gepromoveerd. Een gecentraliseerd register houdt deze metadata bij naast de technische ID en wordt de enige bron van waarheid voor uw team. De onderstaande klasse houdt het essentiële bij in een JSON-bestand: het registreert een kandidaat-model, promoveert er één naar productie terwijl het vorige als ‘met pensioen’ wordt gemarkeerd, geeft de momenteel actieve ID terug en toont de geschiedenis. Neem de tijd om het veld notes in te vullen: één zin over wat er is veranderd sinds de vorige versie bespaart u later een halve dag archeologie.
import json
import datetime
class ModelRegistry:
"""Register van fine-tuned modellen."""
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 = ""
):
"""Registreert een nieuw model in het register."""
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} geregistreerd: {model_id}")
def promote(self, version: str):
"""Promoveert een model naar productie."""
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"Productie: {old} -> {version}")
def rollback(self, version: str):
"""Rollback naar een eerdere versie."""
self.promote(version)
print(f"Rollback uitgevoerd naar {version}")
def production_model(self) -> str:
"""Geeft de ID terug van het model in productie."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Toont de modelgeschiedenis."""
print(f"{'Versie':<12} {'Status':<12} {'Datum':<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)
In de praktijk komt de levenscyclus van een versie neer op drie aanroepen: u registreert het model dat uit de training komt met zijn cijfers, u promoveert het wanneer evaluatie het valideert, en u keert terug naar de vorige versie als productie de evaluatie tegenspreekt. Deze laatste regel moet even triviaal zijn om te schrijven als de eerste twee.
registry = ModelRegistry()
# Registreer een nieuw 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="50 fix-voorbeelden voor restituties toegevoegd"
)
# Promoveer naar productie
registry.promote("v2.1")
# Bij problemen, rollback
registry.rollback("v2.0")
Binnen seconden terugdraaien
Een rollback is alleen waardevol als deze snel is en geen nadenken vereist. Omdat uw applicatie de modelnaam uitleest uit een omgevingsvariabele, betekent een versiewijziging het wijzigen van die variabele en het updaten van het register—geen code-herimplementatie, geen recompilatie. De functie quick_rollback gaat verder door de menselijke keuze volledig over te slaan: deze pakt de laatst beschikbare stabiele versie en valt, als die er niet is, terug op het basismodel. Deze laatste tak is uw absolute veiligheidsnet; activeer deze bewust één keer in een testomgeving, zolang de inzet nog nul is.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Implementeert een model door de omgevingsvariabele bij te werken."""
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"Versie {version} niet gevonden")
# Configuratie bijwerken
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Model geïmplementeerd: {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Rollback naar de laatst stabiele versie."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Fallback naar basismodel
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Rollback naar basismodel")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Archiveer de data, niet alleen de modellen
Een model versioneren zonder te versioneren wat het heeft geproduceerd, brengt u slechts halverwege. De dag dat u wilt begrijpen waarom v2.1 de toon beter hield dan v2.2, heeft u de exacte drie bestanden nodig die zijn gebruikt om het te trainen, inclusief de testset—zonder dit is geen enkele latere vergelijking eerlijk. Archiveer ze in een map met het versienummer, op het exacte moment dat u het model registreert.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Archiveert trainingsdata voor een gegeven versie."""
folder = f"{archive_folder}/{version}"
os.makedirs(folder, exist_ok=True)
for file in files:
shutil.copy2(file, folder)
print(f"Data gearchiveerd in {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Automatiseer de volledige pipeline
Deze stappen, met de hand uitgevoerd, worden uiteindelijk overgeslagen—vooral archiveren, dat als laatste komt en niets blokkeert. Breng ze samen in één script dat bestandsupload, job-start, wachten op voltooiing, registratie in het register en vervolgens archivering van de data achter elkaar uitvoert. De wachtlus vraagt de job elke dertig seconden uit en stopt bij een terminale status; bij falen keert de functie onmiddellijk terug in plaats van door te gaan met een niet-bestaand model.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Volledige pipeline: uploaden, trainen, evalueren, registreren."""
client = OpenAI()
registry = ModelRegistry()
# 1. Uploaden
print("Data uploaden...")
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. Trainen
print("Fine-tuning starten...")
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. Wachten op voltooiing
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"Mislukt: {job.error}")
return None
# 4. Registreren
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. Data archiveren
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline voltooid: {job.fine_tuned_model}")
return job.fine_tuned_model
Opruimen
Fine-tuned modellen worden opgeslagen bij OpenAI en kunnen worden verwijderd wanneer u ze niet meer nodig heeft. Na een dozijn iteraties wordt de lijst onleesbaar en handmatig sorteren gevaarlijk. De onderstaande automatische opruiming houdt de drie meest recente versies bij en raakt nooit degene die in productie draait. Wees niet te agressief: het is juist de op één na laatste versie, vaak als nutteloos beschouwd, die u redt tijdens een rollback.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Verwijdert oude modellen met behoud van de laatste 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"Verwijderd: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Fout bij verwijderen {m['version']}: {e}")
Belangrijkste punten
- Gebruik versioneerde suffixes om elk model te identificeren
- Onderhoud een gecentraliseerd register met metrics en metadata
- Implementeer een snel rollback-mechanisme
- Archiveer trainingsdata bij elke versie
- Automatiseer de pipeline en ruim regelmatig oude modellen op: minder menselijke fouten, minder onnodige kosten
Test uw kennis
Voordat u uw modellen versioneert, valideert u de volledige fine-tuning cyclus.
1. Wanneer is fine-tuning het juiste instrument—en wanneer niet?
Antwoord: Goed voor het verankeren van een stijl, formaat of terugkerend gedrag dat prompting niet betrouwbaar bereikt; slecht voor het injecteren van verse kennis—dat is de rol van RAG.
2. Wat maakt een trainingsdataset van hoge kwaliteit?
Antwoord: Schone, consistente en representatieve voorbeelden in conversatie-JSONL-formaat: een paar honderd uitstekende voorbeelden verslaan duizenden ruisende.
3. Wat brengt DPO in vergelijking met supervised fine-tuning?
Antwoord: Preference learning: u levert paren van geprefereerde/afgewezen antwoorden aan, en het model leert “beter” in plaats van simpele imitatie—nuttig voor toon en fijne afwegingen.
4. Hoe valideert u een fine-tuned model?
Antwoord: Door het te vergelijken met het basismodel op een evaluatieset die gescheiden is van de training, en vervolgens door A/B-testen op bedrijfsmetrics—nooit op indruk alleen.
5. Waarom versioneren en plannen voor rollback?
Antwoord: Elke fine-tuning produceert een gedateerd model: bij regressie in productie schakelt u onmiddellijk terug naar de vorige versie—het model wordt beheerd als code.
Schone data, eerlijke evaluatie, gecontroleerde versies: fine-tuning is een engineeringdiscipline—deze cursus heeft u de volledige cyclus gegeven.