Versionimine ja taastamine
Sellel lehel
Uuendus 2. novembril 2026 — Häälestamise kättesaadavus. OpenAI iseteeninduslik häälestamine kaotatakse järk-järgult: alates 7. maist 2026 ei saa organisatsioonid, kes seda kunagi kasutanud pole, enam uusi töid luua; alates 2. juulist peab olema viimase 60 päeva jooksul kasutatud häälestatud mudelit; ja alates 6. jaanuarist 2027 ei saa ükski klient uusi töid käivitada. Juba treenitud mudelid jäävad kasutatavaks kuni nende baasmudeli kasutusest kõrvaldamiseni. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja ärakasutamiseks; uute projektide puhul eelista viibutamistehnikat (prompt engineering), RAG-i ja hindamist.
Miks oma mudeleid versioonida
Tootmises teed oma häälestatud mudeliga iteratsioone: uusi andmeid, kohandatud hüperparameetreid, uus baasmudel. Ilma range versioonimissüsteemita kaotad jälgitavuse ja võime taastada eelmist seisundit regressiooni korral. Stsenaarium on alati sama: esmaspäeva hommikul halveneb kasutajate tagasiside, keegi ei tea, milline mudel tegelikult töötab või millised andmed selle lõid, ja meeskond veedab päeva info taastamisega, mida mõnerealine fail oleks säilitanud.
Versioonide nimetamine
Häälestustöö suffix parameeter on sinu esimene jälgitavuse tööriist: sinna paigutatud string jõuab mudeli lõplikku ID-sse ja jääb loetavaks kõikjal – sinu logides, konfiguratsioonis, konsoolis. Võta omaks kindel reegel ja pea sellest kinni.
# Reegel: {nimi}-v{põhiversioon}.{alamversioon}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Number ise peab kandma informatsiooni, mitte lihtsalt katsete lugemist. Põhiversioon muutub, kui mudeli olemus muutub; alamversioon, kui täiustad ilma katkestusteta. Konkreetsemalt: andmete parandus sama hüperparameetritega jääb samale põhiversioonile, samas kui baasmudeli vahetus nõuab uue alustamist.
| Versioon | Mida see annab märku |
|---|---|
| v1.0 | Tootmises kinnitatud esimene mudel |
| v1.1 | Andmete parandus (samad hüperparameetrid) |
| v2.0 | Baasmudeli või strateegia vahetus |
| v2.1 | Hüperparameetrite kohandamine |
Mudeliregistri haldamine
Pelgalt nimest ei piisa: see ei ütle midagi andmestiku sisu, saadud tulemuste ega selle kohta, miks see versioon tootmisse tõsteti. Tsentraliseeritud register hoiab need metaandmed tehnilise ID kõrval ja saab sinu meeskonna ainsaks tõeallikaks. Allpool olev klass hoiab olulisemat JSON-failis: see salvestab kandidaatmudeli, tõstab ühe tootmisse, märkides eelmise taandunuks, tagastab praegu aktiivse ID ja kuvab ajaloo. Võta aega, et täita väli notes: üks lause selle kohta, mis eelmise versiooniga võrreldes muutus, säästab sul hiljem pool päeva arheoloogiat.
import json
import datetime
class ModelRegistry:
"""Häälestatud mudelite register."""
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 = ""
):
"""Salvestab uue mudeli registrisse."""
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):
"""Tõstab mudeli tootmisse."""
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):
"""Taastab eelmise versiooni."""
self.promote(version)
print(f"Rollback performed to {version}")
def production_model(self) -> str:
"""Tagastab tootmises oleva mudeli ID."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Kuvab mudelite ajaloo."""
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)
Praktikas taandub versiooni elutsükkel kolmele väljakutsele: salvestad treeningust tulnud mudeli selle näitajatega, tõstad selle tootmisse, kui hindamine selle kinnitab, ja pöördud eelmisele versioonile, kui tootmine hindamise ümber lükkab. See viimane rida peaks olema sama triviaalne kirjutada kui kaks esimest.
registry = ModelRegistry()
# Salvesta uus mudel
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"
)
# Tõsta tootmisse
registry.promote("v2.1")
# Hädajuhtumil taasta
registry.rollback("v2.0")
Taastamine sekunditega
Taastamine on väärtuslik ainult siis, kui see on kiire ega nõua mõtlemist. Kuna sinu rakendus loeb mudeli nime keskkonnamuutujast, tähendab versiooni vahetamine selle muutuja muutmist ja registri uuendamist – ilma koodi ümberpaigutamiseta, ilma ümberkompileerimiseta. Funktsioon quick_rollback läheb kaugemale, välistades täielikult inimliku valiku: see võtab viimase olemasoleva stabiilse versiooni ja kui seda pole, langeb tagasi baasmudelile. See viimane haru on sinu absoluutne ohutusvõrk; käivita see tahtlikult üks kord testkeskkonnas, kui panused on nullid.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Paigaldab mudeli, uuendades keskkonnamuutujat."""
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")
# Uuenda konfiguratsiooni
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):
"""Taasta viimane stabiilne versioon."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Langus baasmudelile
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)
Arhiveeri andmed, mitte ainult mudelid
Mudeli versioonimine ilma seda tekitanud andmete versioonimiseta viib sind vaid poolele teele. Päeval, kui soovid mõista, miks hoidis v2.1 tooni paremini kui v2.2, vajad täpselt neid kolme faili, mida selle treenimiseks kasutati, kaasa arvatud testkomplekt – ilma selleta pole ükski hilisem võrdlus õiglane. Arhiveeri need versiooninumberiga kausta täpselt sel hetkel, kui mudeli salvestad.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Arhiveerib treeningandmed antud versiooni jaoks."""
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"
)
Automatiseeri kogu torustik
Need käsitsi tehtud sammud jäävad lõpuks vahele – eriti arhiveerimine, mis tuleb viimasena ja ei blokeeri midagi. Koonda need üheks skriptiks, mis aheldab failide üleslaadimise, töö käivitamise, ootamise lõpuleviimiseni, registrisse salvestamise ja seejärel andmete arhiveerimise. Ootetsükkel päringutab tööd iga kolmekümne sekundi tagant ja peatub lõppstaatuses; ebaõnnestumise korral naaseb funktsioon koheselt, mitte ei jätka olematu mudeliga.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Täielik torustik: üleslaadimine, treenimine, hindamine, salvestamine."""
client = OpenAI()
registry = ModelRegistry()
# 1. Üleslaadimine
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. Treenimine
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. Oota lõpuleviimist
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. Salvestamine
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. Andmete arhiveerimine
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline complete: {job.fine_tuned_model}")
return job.fine_tuned_model
Puhastamine
Häälestatud mudelid salvestatakse OpenAI-sse ja need saab kustutada, kui neid enam ei vajata. Pärast tosinat iteratsiooni muutub nimekiri loetamatuks ja käsitsi sorteerimine ohtlikuks. Allpool olev automaatne puhastus hoiab alles kolm viimast versiooni ja ei puuduta kunagi tootmises jooksvat. Ära ole liiga agressiivne: just eelviimane versioon, mida sageli kasutuks peetakse, päästab sind taastamise ajal.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Kustutab vanad mudelid, hoides alles viimased 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}")
Peamised punktid
- Kasuta versioneeritud sufikseid iga mudeli identifitseerimiseks
- Hoia keskses registris mõõdikuid ja metaandmeid
- Rakenda kiire taastamise mehhanism
- Arhiveeri treeningandmed iga versiooniga
- Automatiseeri torustik ja puhasta regulaarselt vanu mudeleid: vähem inimlikke vigu, vähem tarbetuid kulusid
Testi oma teadmisi
Enne mudelite versioonimist valideeri kogu häälestamise tsükkel.
1. Millal on häälestamine õige tööriist ja millal mitte?
Vastus: Hea stiili, vormingu või korduva käitumise ankurdamiseks, mida viibutamine usaldusväärselt ei saavuta; halb värskete teadmiste sisendamiseks – see on RAG-i roll.
2. Mis teeb treeningandmestiku kõrge kvaliteediga?
Vastus: Puhtad, järjekindlad ja esinduslikud näited vestluslikus JSONL-vormingus: mõnisada suurepärast näidet lööb tuhandeid müralisi.
3. Mida toob DPO võrreldes järelevalve all häälestamisega?
Vastus: Eelistuste õppimine: esitad eelistatud/tagasilükatud vastuste paarid ja mudel õpib „paremat“ mitte lihtsat jäljendamist – kasulik tooni ja peente kompromisside jaoks.
4. Kuidas valideerida häälestatud mudelit?
Vastus: Võrreldes seda baasmudeliga hindamiskomplektis, mida hoitakse treeningust eraldi, ja seejärel A/B-testimisega ärimõõdikute põhjal – mitte kunagi pelgalt mulje põhjal.
5. Miks versioonida ja planeerida taastamist?
Vastus: Iga häälestamine loob dateeritud mudeli: regressiooni korral tootmises lülitud koheselt eelmisele versioonile – mudelit hallatakse nagu koodi.
Puhtad andmed, aus hindamine, kontrollitud versioonid: häälestamine on inseneridistsipliin – see kursus on andnud sulle kogu tsükli.