Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Versioning en Rollback

Les 16 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom u modellen moet versioneren
  2. Versies benoemen
  3. Een modelregister onderhouden
  4. Binnen seconden terugdraaien
  5. Archiveer de data, niet alleen de modellen
  6. Automatiseer de volledige pipeline
  7. Opruimen
  8. Belangrijkste punten
  9. Test uw kennis

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.

VersieWat het signaleert
v1.0Eerste model gevalideerd in productie
v1.1Data-fix (zelfde hyperparameters)
v2.0Wijziging van basismodel of strategie
v2.1Aanpassing 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.