Versionierung und Rollback
Auf dieser Seite
Update vom 2. November 2026 — Verfügbarkeit des Feinabstimmens. Der Selbstbedienungsdienst für Feinabstimmung bei OpenAI wird schrittweise eingestellt: Seit dem 7. Mai 2026 können Organisationen, die diesen Dienst noch nie genutzt haben, keine Jobs erstellen; seit dem 2. Juli müssen Sie ein feinabgestimmtes Modell innerhalb der letzten 60 Tage verwendet haben; und ab dem 6. Januar 2027 können keine neuen Jobs mehr gestartet werden. Bereits trainierte Modelle bleiben nutzbar, bis ihr Basismodell eingestellt wird. Dieser Kurs bleibt nützlich, um ein bestehendes Modell zu verstehen und zu nutzen; für neue Projekte priorisieren Sie Prompt Engineering, RAG und Evaluierungen.
Warum Sie Ihre Modelle versionieren sollten
In der Produktion werden Sie Ihr feinabgestimmtes Modell iterieren: neue Daten, angepasste Hyperparameter, neues Basismodell. Ohne ein rigoroses Versionierungssystem verlieren Sie die Nachverfolgbarkeit und die Fähigkeit, im Falle einer Regression zurückzurollen. Das Szenario ist immer dasselbe: an einem Montagmorgen verschlechtert sich das Benutzerfeedback, niemand weiß, welches Modell tatsächlich läuft oder welche Daten es erzeugt haben, und das Team verbringt den Tag damit, Informationen zu rekonstruieren, die eine Datei mit wenigen Zeilen erhalten hätte.
Benennung von Versionen
Der Parameter suffix des Feinabstimmungsjobs ist Ihr erstes Werkzeug zur Nachverfolgbarkeit: Der String, den Sie dort platzieren, findet sich in der finalen ID des Modells wieder und bleibt überall lesbar – in Ihren Logs, Ihrer Konfiguration und Ihrer Konsole. Adoptieren Sie eine Konvention und halten Sie sich daran.
# Konvention: {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"
)
Die Zahl selbst muss Informationen tragen, nicht nur Versuche zählen. Eine Hauptversion ändert sich, wenn sich die Natur des Modells ändert; eine Nebenversion, wenn Sie verbessern, ohne zu brechen. Konkret bleibt ein Datenfix, das mit denselben Hyperparametern angewendet wird, auf derselben Hauptversion, während eine Änderung des Basismodells den Start einer neuen Version erfordert.
| Version | Was es signalisiert |
|---|---|
| v1.0 | Erstes Modell, das in der Produktion validiert wurde |
| v1.1 | Datenfix (gleiche Hyperparameter) |
| v2.0 | Änderung des Basismodells oder der Strategie |
| v2.1 | Anpassung der Hyperparameter |
Ein Modellregister pflegen
Der Name allein reicht nicht: Er sagt nichts darüber aus, was im Datensatz war, welche Ergebnisse erzielt wurden oder warum diese Version befördert wurde. Ein zentralisiertes Register hält diese Metadaten neben der technischen ID und wird zur einzigen Wahrheit für Ihr Team. Die Klasse unten hält die wesentlichen Daten in einer JSON-Datei: Sie erfasst ein Kandidatenmodell, befördert eines in die Produktion und markiert das vorherige als eingestellt, gibt die aktuell aktive ID zurück und zeigt die Historie an. Nehmen Sie sich Zeit, das Feld notes auszufüllen: Ein einziger Satz darüber, was sich seit der vorherigen Version geändert hat, spart Ihnen später die Hälfte eines Tages an Archäologie.
import json
import datetime
class ModelRegistry:
"""Registry of fine-tuned models."""
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 = ""
):
"""Records a new model in the registry."""
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):
"""Promotes a model to production."""
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):
"""Rollback to a previous version."""
self.promote(version)
print(f"Rollback performed to {version}")
def production_model(self) -> str:
"""Returns the ID of the model in production."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Displays the model history."""
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)
In der Praxis reduziert sich der Lebenszyklus einer Version auf drei Aufrufe: Sie erfassen das Modell, das aus dem Training kommt, mit seinen Zahlen, befördern es, wenn die Evaluierung es validiert, und kehren zur vorherigen Version zurück, wenn die Produktion der Evaluierung widerspricht. Diese letzte Zeile sollte so trivial zu schreiben sein wie die ersten beiden.
registry = ModelRegistry()
# Record a new 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="Added 50 fix examples for refunds"
)
# Promote to production
registry.promote("v2.1")
# In case of trouble, rollback
registry.rollback("v2.0")
Rollback in Sekunden
Ein Rollback ist nur wertvoll, wenn es schnell ist und keine Überlegung erfordert. Da Ihre Anwendung den Modellnamen aus einer Umgebungsvariable liest, bedeutet das Ändern von Versionen das Ändern dieser Variable und das Aktualisieren des Registers – keine Code-Neubereitstellung, keine Neukompilierung. Die Funktion quick_rollback geht noch einen Schritt weiter, indem sie die menschliche Auswahl vollständig umgeht: Sie nimmt die letzte verfügbare stabile Version und fällt im Falle eines Fehlschlags auf das Basismodell zurück. Dieser letzte Zweig ist Ihr absolutes Sicherheitsnetz; aktivieren Sie ihn freiwillig einmal in einer Testumgebung, während die Risiken null sind.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Deploys a model by updating the environment variable."""
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")
# Update configuration
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):
"""Rollback to the last stable 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 to base model
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)
Archivieren Sie die Daten, nicht nur die Modelle
Die Versionierung eines Modells ohne Versionierung dessen, was es erzeugt hat, bringt Sie nur zur Hälfte. Der Tag, an dem Sie verstehen wollen, warum v2.1 den Ton besser hielt als v2.2, benötigen Sie die exakten drei Dateien, die zum Training verwendet wurden, einschließlich des Testsets – ohne diese ist kein nachfolgender Vergleich fair. Archivieren Sie sie in einem Ordner, der die Versionsnummer trägt, genau zum Zeitpunkt, an dem Sie das Modell erfassen.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Archives training data for a given version."""
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"
)
Automatisieren Sie den gesamten Pipeline
Diese Schritte, die manuell ausgeführt werden, werden irgendwann übersprungen – insbesondere das Archivieren, das zuletzt kommt und nichts blockiert. Sammeln Sie sie in einem einzigen Skript, das Datei-Upload, Job-Start, Warten auf Abschluss, Erfassen im Register und dann Archivieren der Daten verknüpft. Der Warteschleife fragt den Job alle 30 Sekunden ab und stoppt bei einem terminalen Status; im Falle eines Fehlers gibt die Funktion sofort zurück, anstatt mit einem nicht existierenden Modell fortzufahren.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Full pipeline: upload, train, evaluate, record."""
client = OpenAI()
registry = ModelRegistry()
# 1. Upload
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. Training
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. Wait for completion
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. Record
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. Archive data
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline complete: {job.fine_tuned_model}")
return job.fine_tuned_model
Aufräumen
Feinabgestimmte Modelle werden bei OpenAI gespeichert und können gelöscht werden, wenn Sie sie nicht mehr benötigen. Nach einem Dutzend Iterationen wird die Liste unlesbar und das manuelle Sortieren gefährlich. Die automatische Aufräumfunktion unten behält die drei neuesten Versionen und berührt niemals diejenige, die in der Produktion läuft. Seien Sie nicht zu aggressiv: Es ist genau die vorletzte Version, die oft als nutzlos gilt, die Sie während eines Rollbacks retten wird.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Deletes old models keeping the last 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"Deleted: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Error deleting {m['version']}: {e}")
Kernaussagen
- Nutzen Sie versionierte Suffixe, um jedes Modell zu identifizieren
- Pflegen Sie ein zentralisiertes Register mit Metriken und Metadaten
- Implementieren Sie einen schnellen Rollback-Mechanismus
- Archivieren Sie Trainingsdaten mit jeder Version
- Automatisieren Sie die Pipeline und reinigen Sie regelmäßig alte Modelle auf: weniger menschliche Fehler, weniger unnötige Kosten
Testen Sie Ihr Wissen
Bevor Sie Ihre Modelle versionieren, validieren Sie den gesamten Feinabstimmungszyklus.
1. Wann ist Feinabstimmung das richtige Werkzeug – und wann nicht?
Antwort: Gut geeignet, um einen Stil, ein Format oder ein wiederkehrendes Verhalten zu verankern, das durch Prompting nicht zuverlässig erreicht wird; schlecht geeignet, um neues Wissen einzuspeisen – das ist die Rolle von RAG.
2. Was macht einen Trainingsdatensatz von hoher Qualität aus?
Antwort: Saubere, konsistente und repräsentative Beispiele im konversationellen JSONL-Format: Ein paar hundert hervorragende Beispiele schlagen tausende verrauschte.
3. Was bringt DPO im Vergleich zum überwachten Feinabstimmung?
Antwort: Präferenzlernen: Sie stellen bevorzugte/abgelehnte Antwortpaare bereit, und das Modell lernt „besser” statt einfacher Nachahmung – nützlich für Ton und feine Abwägungen.
4. Wie validieren Sie ein feinabgestimmtes Modell?
Antwort: Indem Sie es mit dem Basismodell auf einem Evaluierungssatz vergleichen, der vom Training getrennt ist, und dann durch A/B-Tests auf Geschäftsmetriken – niemals nur auf Eindruck.
5. Warum versionieren und für Rollback planen?
Antwort: Jede Feinabstimmung erzeugt ein datiertes Modell: Im Falle einer Regression in der Produktion wechseln Sie sofort zur vorherigen Version zurück – das Modell wird wie Code verwaltet.
Saubere Daten, ehrliche Evaluierung, kontrollierte Versionen: Feinabstimmung ist eine Ingenieursdisziplin – dieser Kurs hat Ihnen den gesamten Zyklus gegeben.