Wersjonowanie i przywracanie poprzednich wersji
Na tej stronie
Aktualizacja z 2 listopada 2026 r. — Dostępność dostrajania. Usługa samodzielnego dostrajania modeli OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy wcześniej z niej nie korzystały, nie mogą już tworzyć nowych zadań; od 2 lipca konieczne jest używanie dostrajonego modelu przynajmniej raz na 60 dni; a począwszy od 6 stycznia 2027 r. żaden klient nie będzie mógł uruchamiać nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs nadal przydaje się do zrozumienia i wykorzystania istniejących modeli; w przypadku nowych projektów priorytetowo potraktuj inżynierię promptów, RAG oraz ewaluację.
Dlaczego warto wersjonować modele
W środowisku produkcyjnym będziesz iteracyjnie rozwijać swój dostrajany model: nowe dane, dostosowane hiperparametry, nowy model bazowy. Bez rygorystycznego systemu wersjonowania stracisz możliwość śledzenia zmian i przywrócenia poprzedniej wersji w przypadku regresji. Scenariusz jest zawsze ten sam: w poniedziałek rano opinie użytkowników pogarszają się, nikt nie wie, który model faktycznie działa ani jakie dane go wygenerowały, a zespół spędza cały dzień na odtwarzaniu informacji, które mógłby zachować kilkulinijkowy plik.
Nazewnictwo wersji
Parametr suffix zadania dostrajania to Twoje pierwsze narzędzie do śledzenia zmian: ciąg znaków, który tam umieścisz, trafi do końcowego identyfikatora modelu i będzie czytelny wszędzie — w logach, konfiguracji i konsoli. Przyjmij konwencję i się jej trzymaj.
# Konwencja: {nazwa}-v{wersja_główna}.{wersja_pomocnicza}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Sam numer musi nieść informacje, a nie tylko liczyć kolejne próby. Wersję główną zmieniasz, gdy zmienia się natura modelu; wersję pomocniczą — gdy wprowadzasz ulepszenia bez łamania kompatybilności. Konkretnie: poprawka danych zastosowana przy tych samych hiperparametrach pozostaje w tej samej wersji głównej, natomiast zmiana modelu bazowego wymaga rozpoczęcia nowej serii.
| Wersja | Co sygnalizuje |
|---|---|
| v1.0 | Pierwszy model zatwierdzony do produkcji |
| v1.1 | Poprawka danych (te same hiperparametry) |
| v2.0 | Zmiana modelu bazowego lub strategii |
| v2.1 | Dostosowanie hiperparametrów |
Prowadzenie rejestru modeli
Sama nazwa nie wystarczy: nie mówi nic o zawartości zbioru danych, uzyskanych wynikach ani powodach awansu tej konkretnej wersji. Centralny rejestr przechowuje te metadane obok technicznego identyfikatora i staje się dla Twojego zespołu jedinym źródłem prawdy. Poniższa klasa przechowuje essentials w pliku JSON: rejestruje model kandydujący, promuje jeden do produkcji, oznaczając poprzedni jako wycofany, zwraca obecnie aktywny identyfikator i wyświetla historię. Poświęć czas na wypełnienie pola notes: jedno zdanie o tym, co zmieniło się względem poprzedniej wersji, zaoszczędzi Ci później pół dnia archeologii.
import json
import datetime
class ModelRegistry:
"""Rejestr dostrajanych modeli."""
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 = ""
):
"""Rejestruje nowy model w rejestrze."""
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} zarejestrowany: {model_id}")
def promote(self, version: str):
"""Promuje model do produkcji."""
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"Produkcja: {old} -> {version}")
def rollback(self, version: str):
"""Przywraca poprzednią wersję."""
self.promote(version)
print(f"Przywrócono wersję {version}")
def production_model(self) -> str:
"""Zwraca identyfikator modelu w produkcji."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Wyświetla historię modeli."""
print(f"{'Wersja':<12} {'Status':<12} {'Data':<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)
W praktyce cykl życia wersji sprowadza się do trzech wywołań: rejestrujesz model po zakończeniu treningu wraz z jego metrykami, promujesz go, gdy ewaluacja go zatwierdzi, i cofasz się do poprzedniej wersji, jeśli produkcja zaprzeczy wynikom ewaluacji. Ta ostatnia linijka powinna być tak samo trywialna do zapisania jak dwie pierwsze.
registry = ModelRegistry()
# Rejestracja nowego modelu
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="Dodano 50 przykładów naprawczych dotyczących zwrotów"
)
# Promocja do produkcji
registry.promote("v2.1")
# W przypadku problemów – przywrócenie poprzedniej wersji
registry.rollback("v2.0")
Przywracanie wersji w kilka sekund
Przywracanie wersji ma sens tylko wtedy, gdy jest szybkie i nie wymaga zastanawiania się. Ponieważ Twoja aplikacja odczytuje nazwę modelu ze zmiennej środowiskowej, zmiana wersji oznacza zmianę tej zmiennej i aktualizację rejestru — bez ponownego wdrażania kodu, bez rekompilacji. Funkcja quick_rollback idzie o krok dalej, całkowicie pomijając ludzki wybór: wybiera ostatnią dostępną stabilną wersję, a jeśli takiej nie ma, cofa się do modelu bazowego. Ta ostatnia gałąź to Twoja absolutna siatka bezpieczeństwa; uruchom ją dobrowolnie raz w środowisku testowym, gdy stawka wynosi zero.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Wdraża model poprzez aktualizację zmiennej środowiskowej."""
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"Wersja {version} nie została znaleziona")
# Aktualizacja konfiguracji
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Wdrożono model: {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Przywraca ostatnią stabilną wersję."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Cofnięcie do modelu bazowego
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Przywrócono model bazowy")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Archiwizuj dane, a nie tylko modele
Wersjonowanie modelu bez wersjonowania tego, co go wygenerowało, to tylko połowa sukcesu. Gdy będziesz chciał zrozumieć, dlaczego wersja v2.1 lepiej utrzymała ton niż v2.2, potrzebować będziesz dokładnie tych trzech plików, których użyto do jej treningu, łącznie ze zbiorem testowym — bez nich żadne późniejsze porównanie nie będzie uczciwe. Zarchiwizuj je w folderze oznaczonym numerem wersji dokładnie w momencie rejestracji modelu.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Archiwizuje dane treningowe dla danej wersji."""
folder = f"{archive_folder}/{version}"
os.makedirs(folder, exist_ok=True)
for file in files:
shutil.copy2(file, folder)
print(f"Dane zarchiwizowane w {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Automatyzacja pełnego potoku
Te kroki, wykonywane ręcznie, z czasem zaczynają być pomijane — zwłaszcza archiwizacja, która comes last i niczego nie blokuje. Zbierz je w jednym skrypcie, który łączy przesyłanie plików, uruchamianie zadania, oczekiwanie na jego zakończenie, rejestrację w rejestrze, a następnie archiwizację danych. Pętla oczekiwania odpytuje zadanie co trzydzieści sekund i zatrzymuje się przy statusie końcowym; w przypadku niepowodzenia funkcja natychmiast zwraca wynik, zamiast kontynuować z nieistniejącym modelem.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Pełny potok: przesyłanie, trening, ewaluacja, rejestracja."""
client = OpenAI()
registry = ModelRegistry()
# 1. Przesyłanie
print("Przesyłanie danych...")
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. Trening
print("Uruchamianie dostrajania...")
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. Oczekiwanie na zakończenie
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"Niepowodzenie: {job.error}")
return None
# 4. Rejestracja
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. Archiwizacja danych
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Potok zakończony: {job.fine_tuned_model}")
return job.fine_tuned_model
Porządki
Dostrajane modele są przechowywane w OpenAI i można je usunąć, gdy przestaną być potrzebne. Po kilkunastu iteracjach lista staje się nieczytelna, a ręczne sortowanie — niebezpieczne. Poniższe automatyczne czyszczenie zachowuje trzy najnowsze wersje i nigdy nie dotyka tej działającej w produkcji. Unikaj zbyt agresywnego podejścia: to właśnie przedostatnia wersja, często uznawana za bezużyteczną, uratuje Cię podczas przywracania.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Usuwa stare modele, zachowując ostatnie 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"Usunięto: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Błąd usuwania {m['version']}: {e}")
Kluczowe wnioski
- Używaj wersjonowanych sufiksów do identyfikacji każdego modelu
- Prowadź centralny rejestr z metrykami i metadanymi
- Wdróż mechanizm szybkiego przywracania poprzednich wersji
- Archiwizuj dane treningowe dla każdej wersji
- Automatyzuj potok i regularnie czyść stare modele: mniej błędów ludzkich, mniej niepotrzebnych kosztów
Sprawdź swoją wiedzę
Zanim zaczniesz wersjonować modele, zwaliduj pełny cykl dostrajania.
1. Kiedy dostrajanie jest właściwym narzędziem — a kiedy nie?
Odpowiedź: Dobre do utrwalenia stylu, formatu lub powtarzalnego zachowania, którego nie da się reliably osiągnąć promptami; złe do wprowadzania świeżej wiedzy — to rola RAG.
2. Co sprawia, że zbiór danych treningowych jest wysokiej jakości?
Odpowiedź: Czyste, spójne i reprezentatywne przykłady w formacie konwersacyjnym JSONL: kilkaset doskonałych przykładów bije na głowę tysiące zaszumionych.
3. Co wnosi DPO w porównaniu z nadzorowanym dostrajaniem?
Odpowiedź: Naukę preferencji: dostarczasz pary odpowiedzi preferowanych/odrzuconych, a model uczy się, co jest „lepsze“, a nie tylko naśladuje — przydatne do tonu i subtelnych kompromisów.
4. Jak walidujesz dostrajany model?
Odpowiedź: Porównując go z modelem bazowym na zbiorze ewaluacyjnym oddzielonym od treningu, a następnie poprzez testy A/B na metrykach biznesowych — nigdy wyłącznie na podstawie wrażenia.
5. Dlaczego warto wersjonować i planować przywracanie poprzednich wersji?
Odpowiedź: Każde dostrajanie generuje model z datą: w przypadku regresji w produkcji natychmiast przełączasz się na poprzednią wersję — modelem zarządzasz jak kodem.
Czyste dane, uczciwa ewaluacja, kontrolowane wersje: dostrajanie to dyscyplina inżynierska — ten kurs dał Ci pełny cykl.