Verzioniranje in povratne spremembe
Na tej strani
Posodobitev 2. novembra 2026 — Razpoložljivost prilagajanja. Samostojno prilagajanje (fine-tuning) podjetja OpenAI se postopno ukinja: od 7. maja 2026 organizacije, ki ga še niso uporabljale, ne morejo več ustvarjati opravil; od 2. julija morate prilagojen model uporabiti v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler se njihov osnovni model ne umakne. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječega modela; za nove projekte dajte prednost inženiringu pozivov, RAG in evalvacijam.
Zakaj verzionirati svoje modele
V produkcijskem okolju boste iterirali svoj prilagojeni model: novi podatki, prilagojeni hiperparametri, nov osnovni model. Brez strogega sistema verzioniranja boste izgubili sledljivost in možnost povratka na prejšnjo različico v primeru regresije. Scenarij je vedno enak: v ponedeljek zjutraj se uporabniške povratne informacije poslabšajo, nihče ne ve, kateri model dejansko teče ali kateri podatki so ga proizvedli, ekipa pa dan porabi za rekonstrukcijo informacij, ki bi jih ohranila datoteka z nekaj vrsticami kode.
Poimenovanje različic
Parameter suffix opravila prilagajanja je vaše prvo orodje za sledljivost: niz, ki ga tja vnesete, se konča v končnem ID-ju modela in ostane berljiv povsod – v vaših dnevnikih, konfiguraciji in konzoli. Sprejmite konvencijo in se je držite.
# Konvencija: {ime}-v{glavna_različica}.{stranska_različica}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Številka sama mora nositi informacijo, ne le šteti poskuse. Glavna različica se spremeni, ko se spremeni narava modela; stranska različica, ko izboljšate nekaj brez preloma. Konkretno, popravek podatkov, uporabljen z istimi hiperparametri, ostane na isti glavni različici, medtem ko sprememba osnovnega modela zahteva začetek novega.
| Različica | Kaj signalizira |
|---|---|
| v1.0 | Prvi model, validiran v produkciji |
| v1.1 | Popravek podatkov (isti hiperparametri) |
| v2.0 | Sprememba osnovnega modela ali strategije |
| v2.1 | Prilagoditev hiperparametrov |
Vzdrževanje registra modelov
Samo ime ni dovolj: ne pove ničesar o tem, kaj je bilo v naboru podatkov, kakšni so bili rezultati ali zakaj je bila ta različica promovirana. Centraliziran register hrani te metapodatke ob tehničnem ID-ju in postane edini vir resnice za vašo ekipo. Spodnji razred hrani bistveno v datoteki JSON: zabeleži kandidata za model, promovira enega v produkcijo, pri čemer prejšnjega označi kot umaknjenega, vrne trenutno aktivni ID in prikaže zgodovino. Vzemite si čas za izpolnitev polja notes: en sam stavek o tem, kaj se je spremenilo glede na prejšnjo različico, vam bo kasneje prihranil pol dneva arheologije.
import json
import datetime
class ModelRegistry:
"""Register prilagojenih modelov."""
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 = ""
):
"""Zabeleži nov model v 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} zabeležen: {model_id}")
def promote(self, version: str):
"""Promovira model v produkcijo."""
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"Produkcija: {old} -> {version}")
def rollback(self, version: str):
"""Povratna sprememba na prejšnjo različico."""
self.promote(version)
print(f"Izveden povrat na {version}")
def production_model(self) -> str:
"""Vrne ID modela v produkciji."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Prikaže zgodovino modelov."""
print(f"{'Različica':<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)
V praksi se življenjski cikel različice zreducira na tri klice: zabeležite model, ki pride iz usposabljanja, z njegovimi številkami, promovirate ga, ko evalvacija potrdi njegovo kakovost, in se vrnete na prejšnjo različico, če produkcija nasprotuje evalvaciji. Ta zadnja vrstica mora biti tako trivialna za zapis kot prvi dve.
registry = ModelRegistry()
# Zabeleži nov 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="Dodanih 50 primerov popravkov za vračila"
)
# Promoviraj v produkcijo
registry.promote("v2.1")
# V primeru težav, povratna sprememba
registry.rollback("v2.0")
Povratne spremembe v nekaj sekundah
Povratna sprememba je vredna le, če je hitra in ne zahteva razmišljanja. Ker vaša aplikacija bere ime modela iz spremenljivke okolja, sprememba različice pomeni spremembo te spremenljivke in posodobitev registra – brez ponovne namestitve kode, brez ponovnega prevajanja. Funkcija quick_rollback gre še dlje, saj popolnoma obide človeško izbiro: izbere zadnjo razpoložljivo stabilno različico in, če nobene ni, se vrne na osnovni model. Ta zadnja veja je vaša absolutna varnostna mreža; namerno jo sprožite enkrat v testnem okolju, ko so stave ničelni.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Namesti model s posodobitvijo spremenljivke okolja."""
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"Različica {version} ni najdena")
# Posodobi konfiguracijo
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Model nameščen: {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Povratna sprememba na zadnjo stabilno različico."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Povrat na osnovni model
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Povrat na osnovni model")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Arhiviraj podatke, ne le modelov
Verzioniranje modela brez verzioniranja tega, kar ga je proizvedlo, vas pripelje le do polovice poti. Ko boste želeli razumeti, zakaj je v2.1 bolje ohranil ton kot v2.2, boste potrebovali točno tri datoteke, uporabljene za njegovo usposabljanje, vključno s testnim naborom – brez tega nobena poznejša primerjava ni poštena. Arhivirajte jih v mapo z imenom različice, točno v trenutku, ko zabeležite model.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Arhivira podatke za usposabljanje za dano različico."""
folder = f"{archive_folder}/{version}"
os.makedirs(folder, exist_ok=True)
for file in files:
shutil.copy2(file, folder)
print(f"Podatki arhivirani v {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Avtomatiziraj celoten potek dela
Ti koraki, če se izvajajo ročno, se sčasoma preskočijo – še posebej arhiviranje, ki pride nazadnje in ničesar ne blokira. Združite jih v en sam skript, ki veriži nalaganje datotek, zagon opravila, čakanje na zaključek, zapis v register in nato arhiviranje podatkov. Zanka za čakanje poizveduje opravilo vsakih trideset sekund in se ustavi ob končnem statusu; v primeru napake se funkcija takoj vrne, namesto da bi nadaljevala z neobstoječim modelom.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Celoten potek dela: nalaganje, usposabljanje, evalvacija, zapis."""
client = OpenAI()
registry = ModelRegistry()
# 1. Nalaganje
print("Nalaganje podatkov...")
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. Usposabljanje
print("Zagon prilagajanja...")
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. Čakanje na zaključek
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"Napaka: {job.error}")
return None
# 4. Zapis
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. Arhiviranje podatkov
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Potek dela končan: {job.fine_tuned_model}")
return job.fine_tuned_model
Čiščenje
Prilagojeni modeli so shranjeni pri podjetju OpenAI in jih lahko izbrišete, ko jih ne potrebujete več. Po ducat iteracijah seznam postane neberljiv in ročno razvrščanje nevarno. Spodnje samodejno čiščenje ohrani tri najnovejše različice in se nikoli ne dotakne tiste, ki teče v produkciji. Izogibajte se preveliki agresivnosti: prav predzadnja različica, ki se pogosto šteje za neuporabno, vas bo rešila med povratno spremembo.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Izbriše stare modele, obdrži zadnjih 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"Izbrisano: {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Napaka pri brisanju {m['version']}: {e}")
Ključne ugotovitve
- Uporabite verzionirane pripone za identifikacijo vsakega modela
- Vzdržujte centraliziran register z metrikami in metapodatki
- Implementirajte mehanizem za hiter povrat
- Arhivirajte podatke za usposabljanje z vsako različico
- Avtomatizirajte potek dela in redno čistite stare modele: manj človeških napak, manj nepotrebnih stroškov
Preveri svoje znanje
Preden verzionirate svoje modele, validirajte celoten cikel prilagajanja.
1. Kdaj je prilagajanje pravo orodje in kdaj ni?
Odgovor: Dobro za zasidranje sloga, formata ali ponavljajočega se vedenja, ki ga pozivi ne dosežejo zanesljivo; slabo za vnašanje svežega znanja – to je vloga RAG.
2. Kaj naredi nabor podatkov za usposabljanje visokokakovosten?
Odgovor: Čisti, dosledni in reprezentativni primeri v pogovorni formatu JSONL: nekaj sto odličnih primerov premaga tisoče hrupnih.
3. Kaj prinaša DPO v primerjavi s nadzorovanim prilagajanjem?
Odgovor: Učenje preferenc: zagotovite pare odzivov, ki so preferirani/zavrnjeni, in model se nauči „boljše” namesto preprostega posnemanja – uporabno za ton in fine kompromise.
4. Kako validirate prilagojen model?
Odgovor: S primerjavo z osnovnim modelom na evalvacijskem naboru, ločenem od usposabljanja, nato z A/B testiranjem na poslovnih metrikah – nikoli le na podlagi vtisa.
5. Zakaj verzionirati in načrtovati povratne spremembe?
Odgovor: Vsako prilagajanje proizvede datiran model: v primeru regresije v produkciji takoj preklopite nazaj na prejšnjo različico – z modelom upravljate kot s kodo.
Čisti podatki, poštena evalvacija, nadzorovane različice: prilagajanje je inženirska disciplina – ta tečaj vam je dal celoten cikel.