Versioning och återställning
På denna sida
Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningslösning för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande värdefull för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.
Varför du ska versionera dina modeller
I produktion kommer du att iterera över din finjusterade modell: nya data, justerade hyperparametrar, ny basmodell. Utan ett strikt versioneringssystem förlorar du spårbarheten och möjligheten att rulla tillbaka vid regressioner. Scenariot är alltid detsamma: en måndag morgon försämras användarfeedbacken, ingen vet vilken modell som faktiskt körs eller vilka data som producerade den, och teamet spenderar dagen med att rekonstruera information som en fil på några rader hade kunnat bevara.
Namnge versioner
Parametern suffix i finjusteringsjobbet är ditt första verktyg för spårbarhet: strängen du placerar där hamnar i modellens slutgiltiga ID och förblir läsbar överallt – i dina loggar, din konfiguration och din konsol. Anta en konvention och håll dig till den.
# Konvention: {namn}-v{huvudversion}.{mindre_version}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Siffran i sig måste bära information, inte bara räkna försök. En huvudversion ändras när modellens natur förändras; en mindre version när du förbättrar utan att bryta något. Konkret innebär en datakorrigering med samma hyperparametrar att du stannar på samma huvudversion, medan ett byte av basmodell kräver att du startar en ny.
| Version | Vad det signalerar |
|---|---|
| v1.0 | Första modellen validerad i produktion |
| v1.1 | Datakorrigering (samma hyperparametrar) |
| v2.0 | Byte av basmodell eller strategi |
| v2.1 | Justering av hyperparametrar |
Underhåll ett modellregister
Namnet ensam räcker inte: det säger inget om vad datamängden innehöll, vilka resultat som uppnåddes eller varför denna version promoverades. Ett centralt register håller dessa metadata tillsammans med det tekniska ID:t och blir ditt teams enda sanningskälla. Klassen nedan håller det väsentliga i en JSON-fil: den registrerar en kandidatmodell, promoverar en till produktion samtidigt som den föregående markeras som pensionerad, returnerar det ID som för närvarande är aktivt och visar historiken. Ta dig tid att fylla i fältet notes: en enda mening om vad som ändrats sedan föregående version sparar dig en halv dags arkeologi senare.
import json
import datetime
class ModelRegistry:
"""Register över finjusterade 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 = ""
):
"""Registrerar en ny modell 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"Modell {version} registrerad: {model_id}")
def promote(self, version: str):
"""Promoverar en modell till 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):
"""Återställning till en tidigare version."""
self.promote(version)
print(f"Återställning utförd till {version}")
def production_model(self) -> str:
"""Returnerar ID:t för 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):
"""Visar modellhistoriken."""
print(f"{'Version':<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)
I praktiken reduceras livscykeln för en version till tre anrop: du registrerar modellen som kommer ut från träningen med dess siffror, du promoverar den när utvärderingen validerar den, och du återgår till föregående version om produktionen motsäger utvärderingen. Denna sista rad bör vara lika trivial att skriva som de två första.
registry = ModelRegistry()
# Registrera en ny modell
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="Lade till 50 fix-exempel för återbetalningar"
)
# Promovera till produktion
registry.promote("v2.1")
# Vid problem, återställ
registry.rollback("v2.0")
Återställning på sekunder
En återställning är bara värdefull om den är snabb och kräver inget tänkande. Eftersom din applikation läser modellnamnet från en miljövariabel innebär ett versionsbyte att du ändrar den variabeln och uppdaterar registret – ingen kodomdistribution, ingen omkompilering. Funktionen quick_rollback går ett steg längre genom att helt kringgå mänskligt val: den plockar upp den senaste tillgängliga stabila versionen och, om ingen finns, faller tillbaka på basmodellen. Denna sista gren är ditt absoluta säkerhetsnät; utlös den frivilligt en gång i en testmiljö, medan insatserna är noll.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Distribuerar en modell genom att uppdatera miljövariabeln."""
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} hittades inte")
# Uppdatera konfiguration
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Modell distribuerad: {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Återställning till senaste stabila version."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Fallback till basmodell
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Återställning till basmodell")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Arkivera data, inte bara modeller
Att versionera en modell utan att versionera det som producerade den tar dig bara halva vägen. Den dag du vill förstå varför v2.1 höll tonen bättre än v2.2 kommer du att behöva exakt de tre filer som användes för att träna den, inklusive testmängden – utan den är ingen efterföljande jämförelse rättvis. Arkivera dem i en mapp som bär versionsnumret, precis i det ögonblick du registrerar modellen.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Arkiverar träningsdata för 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 arkiverad i {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Automatisera hela pipelinen
Dessa steg, när de utförs för hand, hoppar man så småningom över – särskilt arkivering, som kommer sist och blockerar ingenting. Samla dem i ett enda skript som kedjar filuppladdning, jobbstart, väntan på slutförande, registrering i registret och sedan arkivering av data. Vänteslingan frågar jobbet var trettionde sekund och stannar vid en terminalstatus; vid fel returnerar funktionen omedelbart istället för att fortsätta med en icke-existerande modell.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Fullständig pipeline: uppladdning, träning, utvärdering, registrering."""
client = OpenAI()
registry = ModelRegistry()
# 1. Uppladdning
print("Laddar upp 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("Startar 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. Vänta på slutförande
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"Misslyckande: {job.error}")
return None
# 4. Registrera
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. Arkivera data
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline klar: {job.fine_tuned_model}")
return job.fine_tuned_model
Rensa upp
Finjusterade modeller lagras på OpenAI och kan raderas när du inte längre behöver dem. Efter ett dussin iterationer blir listan oläslig och manuell sortering farlig. Rensningen nedan behåller de tre senaste versionerna och rör aldrig den som körs i produktion. Undvik att vara för aggressiv: det är precis den näst sista versionen, som ofta anses onödig, som kommer att rädda dig under en återställning.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Raderar gamla modeller men behåller de senaste 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"Raderad: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Fel vid radering av {m['version']}: {e}")
Viktiga punkter
- Använd versionsmärkta suffix för att identifiera varje modell
- Underhåll ett centralt register med mätvärden och metadata
- Implementera en snabb återställningsmekanism
- Arkivera träningsdata för varje version
- Automatisera pipelinen och rensa regelbundet gamla modeller: färre mänskliga fel, färre onödiga kostnader
Testa dina kunskaper
Innan du versionerar dina modeller, validera hela cykeln för finjustering.
1. När är finjustering rätt verktyg – och när är det inte det?
Svar: Bra för att förankra en stil, ett format eller ett återkommande beteende som prompting inte uppnår tillförlitligt; dåligt för att injicera färsk kunskap – det är RAG:s roll.
2. Vad gör en träningsdatamängd högkvalitativ?
Svar: Rena, konsekventa och representativa exempel i konversationsformatet JSONL: några hundra utmärkta exempel slår tusentals brusiga.
3. Vad tillför DPO jämfört med övervakad finjustering?
Svar: Preferensinlärning: du tillhandahåller par av föredragna/avvisade svar, och modellen lär sig “bättre” snarare än enkel imitation – användbart för tonfall och fina avvägningar.
4. Hur validerar du en finjusterad modell?
Svar: Genom att jämföra den med basmodellen på en utvärderingsmängd som hålls separat från träningen, och sedan genom A/B-testning på affärsmätvärden – aldrig baserat på intryck ensam.
5. Varför versionera och planera för återställning?
Svar: Varje finjustering producerar en daterad modell: vid regression i produktion växlar du tillbaka till föregående version omedelbart – modellen hanteras som kod.
Rena data, ärlig utvärdering, kontrollerade versioner: finjustering är en ingenjörsdisciplin – denna kurs har gett dig hela cykeln.