Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Versionering og tilbagerulning

Lektion 16 af 16 Opdateret 2. november 2026 Avanceret
På denne side
  1. Hvorfor du skal versionere dine modeller
  2. Navngivning af versioner
  3. Vedligeholdelse af et modelregister
  4. Tilbagerulning på sekunder
  5. Arkivér dataene, ikke kun modellerne
  6. Automatisér hele pipeline’en
  7. Oprydning
  8. Vigtige pointer
  9. Test din viden

Opdatering 2. november 2026 — Tilgængelighed af finjustering. OpenAIs selvbetjente finjustering udfases: siden 7. maj 2026 kan organisationer, der aldrig har brugt tjenesten, ikke længere oprette jobs; siden 2. juli skal du have brugt en finjusteret model inden for de sidste 60 dage; og fra 6. januar 2027 vil ingen kunde kunne starte nye jobs. Allerede trænede modeller forbliver brugbare, indtil deres basismodel trækkes tilbage. Dette kursus er stadig nyttigt til at forstå og udnytte en eksisterende model; til nye projekter bør du prioritere prompt engineering, RAG og evalueringer.

Hvorfor du skal versionere dine modeller

I produktion vil du iterere på din finjusterede model: nye data, justerede hyperparametre, ny basismodel. Uden et stringent versioneringssystem mister du sporbarheden og evnen til at rulle tilbage ved regression. Scenariet er altid det samme: en mandag morgen forringes brugerfeedbacken, ingen ved hvilken model der faktisk kører, eller hvilke data der producerede den, og teamet bruger dagen på at rekonstruere information, som en fil på få linjer kunne have bevaret.

Parameteren suffix i finjusteringsjobbet er dit første værktøj til sporbarhed: den streng, du placerer der, ender i modellens endelige ID og forbliver læsbar overalt – i dine logs, din konfiguration og din konsol. Vedtag en konvention og hold fast i den.

# Konvention: {navn}-v{hoved_version}.{mindre_version}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

Selve tallet skal bære information, ikke blot tælle forsøg. En hovedversion ændres, når modellens natur ændres; en mindre version, når du forbedrer uden at bryde noget. Konkret betyder en datarettelse anvendt med samme hyperparametre, at du bliver på samme hovedversion, mens en ændring af basismodel kræver, at du starter en ny.

VersionHvad det signalerer
v1.0Første model valideret i produktion
v1.1Datarettelse (samme hyperparametre)
v2.0Ændring af basismodel eller strategi
v2.1Justering af hyperparametre

Vedligeholdelse af et modelregister

Navnet alene er ikke nok: det siger intet om, hvad datasættet indeholdt, hvilke resultater der blev opnået, eller hvorfor denne version blev promoveret. Et centralt register holder disse metadata sammen med det tekniske ID og bliver dit teams eneste sandhetskilde. Klassen nedenfor holder det væsentlige i en JSON-fil: den registrerer en kandidatmodel, promoverer én til produktion, mens den markerer den tidligere som trukket tilbage, returnerer det aktuelt aktive ID og viser historikken. Tag dig tid til at udfylde feltet notes: en enkelt sætning om, hvad der er ændret siden den forrige version, vil spare dig en halv dags arkæologi senere.

import json
import datetime

class ModelRegistry:
    """Register over finjusterede modeller."""

    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 = ""
    ):
        """Registrerer en ny model i registret."""
        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} registreret: {model_id}")

    def promote(self, version: str):
        """Promoverer en model til produktion."""
        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"Produktion: {old} -> {version}")

    def rollback(self, version: str):
        """Tilbagerulning til en tidligere version."""
        self.promote(version)
        print(f"Tilbagerulning udført til {version}")

    def production_model(self) -> str:
        """Returnerer ID'et på modellen i produktion."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Viser modelhistorikken."""
        print(f"{'Version':<12} {'Status':<12} {'Dato':<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)

I praksis reduceres en versions livscyklus til tre kald: du registrerer modellen, der kommer ud af træningen med dens tal, du promoverer den, når evalueringen validerer den, og du vender tilbage til den forrige version, hvis produktionen modsiger evalueringen. Denne sidste linje skal være lige så triviel at skrive som de to første.

registry = ModelRegistry()

# Registrer en ny 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="Tilføjede 50 fikseksempler for refusioner"
)

# Promover til produktion
registry.promote("v2.1")

# Ved problemer, rul tilbage
registry.rollback("v2.0")

Tilbagerulning på sekunder

En tilbagerulning er kun værdifuld, hvis den er hurtig og kræver ingen overvejelse. Da din applikation læser modelnavnet fra en miljøvariabel, betyder ændring af version blot at ændre den variabel og opdatere registret – ingen genudrulning af kode, ingen rekompilering. Funktionen quick_rollback går videre ved helt at omgå menneskelige valg: den finder den sidste tilgængelige stabile version og falder tilbage til basismodellen, hvis ingen findes. Denne sidste gren er dit absolutte sikkerhedsnet; udløs den frivilligt én gang i et testmiljø, mens indsatsen er nul.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Udruller en model ved at opdatere miljøvariablen."""
    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} ikke fundet")

    # Opdater konfiguration
    os.environ["OPENAI_FT_MODEL"] = model_id
    registry.promote(version)

    print(f"Model udrullet: {version} ({model_id})")
    return model_id

def quick_rollback(registry: ModelRegistry):
    """Tilbagerulning til den sidste stabile version."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Fald tilbage til basismodel
        os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
        print("Tilbagerulning til basismodel")
        return

    last_stable = versions[-1]
    deploy_model(last_stable["version"], registry)

Arkivér dataene, ikke kun modellerne

At versionere en model uden at versionere det, der producerede den, bringer dig kun halvvejs. Den dag du vil forstå, hvorfor v2.1 holdt tonen bedre end v2.2, får du brug for de præcis tre filer, der blev brugt til at træne den, inklusive testsættet – uden det er ingen efterfølgende sammenligning retfærdig. Arkivér dem i en mappe med versionsnummeret, præcis i det øjeblik du registrerer modellen.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Arkiverer træningsdata for en given version."""
    folder = f"{archive_folder}/{version}"
    os.makedirs(folder, exist_ok=True)

    for file in files:
        shutil.copy2(file, folder)

    print(f"Data arkiveret i {folder}")

archive_dataset(
    "v2.1",
    ["train.jsonl", "validation.jsonl", "test.jsonl"],
    "archives/datasets"
)

Automatisér hele pipeline’en

Disse trin, udført i hånden, bliver efterhånden sprunget over – især arkivering, som kommer sidst og ikke blokerer noget. Saml dem i ét enkelt script, der kæder filupload, jobstart, venten på fuldførelse, registrering i registret og derefter arkivering af dataene sammen. Venteløkken spørger jobbet hvert tredive sekund og stopper ved en terminal status; ved fejl returnerer funktionen øjeblikkeligt i stedet for at fortsætte med en ikke-eksisterende model.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Fuld pipeline: upload, træning, evaluering, registrering."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Upload
    print("Uploader 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. Træning
    print("Starter finjustering...")
    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. Vent på fuldførelse
    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"Fejl: {job.error}")
        return None

    # 4. Registrering
    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. Arkivér data
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

    print(f"Pipeline fuldført: {job.fine_tuned_model}")
    return job.fine_tuned_model

Oprydning

Finjusterede modeller gemmes på OpenAI og kan slettes, når du ikke længere har brug for dem. Efter et dusin iterationer bliver listen ulæselig, og manuel sortering farlig. Oprydningen nedenfor beholder de tre seneste versioner og rører aldrig den, der kører i produktion. Undgå at være for aggressiv: det er netop den næstsidste version, der ofte anses for ubrugelig, der vil redde dig under en tilbagerulning.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Sletter gamle modeller og beholder de sidste 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"Slettet: {m['version']} ({m['model_id']})")
        except Exception as e:
            print(f"Fejl ved sletning af {m['version']}: {e}")

Vigtige pointer

  • Brug versionerede suffikser til at identificere hver model
  • Vedligehold et centralt register med metriker og metadata
  • Implementér en hurtig mekanisme til tilbagerulning
  • Arkivér træningsdata sammen med hver version
  • Automatisér pipeline’en og ryd regelmæssigt op i gamle modeller: færre menneskelige fejl, færre unødvendige omkostninger

Test din viden

Før du versionerer dine modeller, skal du validere hele finjusteringscyklussen.

1. Hvornår er finjustering det rigtige værktøj – og hvornår er det ikke?

Svar: Godt til at forankre en stil, et format eller en tilbagevendende adfærd, som prompting ikke opnår pålideligt; dårligt til at indskyde ny viden – det er RAGs rolle.

2. Hvad gør et træningssæt til et datasæt af høj kvalitet?

Svar: Rene, konsistente og repræsentative eksempler i konversationelt JSONL-format: et par hundrede fremragende eksempler slår tusindvis af støjende.

3. Hvad bringer DPO med sig sammenlignet med superviseret finjustering?

Svar: Præferenceindlæring: du leverer par af foretrukne/afviste svar, og modellen lærer „bedre” snarere end simpel efterligning – nyttigt til tone og fine afvejninger.

4. Hvordan validerer du en finjusteret model?

Svar: Ved at sammenligne den med basismodellen på et evalueringssæt holdt adskilt fra træningen, og derefter ved A/B-testning på forretningsmål – aldrig alene på mavefornemmelser.

5. Hvorfor versionere og planlægge tilbagerulning?

Svar: Hver finjustering producerer en dateret model: ved regression i produktionen skifter du straks tilbage til den forrige version – modellen håndteres som kode.

Rene data, ærlig evaluering, kontrollerede versioner: finjustering er en ingeniørdisciplin – dette kursus har givet dig hele cyklussen.