Versionointi ja palautus
Tällä sivulla
Päivitys 2. marraskuuta 2026 — Hienosäädön saatavuus. OpenAI:n itsepalveluhienosäätö on poistumassa: 7. toukokuuta 2026 lähtien organisaatiot, jotka eivät ole koskaan käyttäneet sitä, eivät voi enää luoda töitä; 2. heinäkuuta lähtien sinun on täytynyt käyttää hienosäädettyä mallia viimeisen 60 päivän aikana; ja 6. tammikuuta 2027 alkaen mikään asiakas ei voi käynnistää uusia töitä. Jo koulutetut mallit pysyvät käytössä, kunnes niiden pohjamalli poistetaan käytöstä. Tämä kurssi on edelleen hyödyllinen olemassa olevan mallin ymmärtämiseen ja hyödyntämiseen; uusissa projekteissa priorisoi kehotetekniikkaa (prompt engineering), RAG:ia ja arviointia.
Miksi malleja kannattaa versioida
Tuotantoympäristössä iteroit hienosäädettyä malliasi: uutta dataa, säädettyjä hyperparametreja, uusi pohjamalli. Ilman tiukkaa versionointijärjestelmää menetät jäljitettävyyden ja kyvyn palata edelliseen versioon regressiotilanteessa. Skenaario on aina sama: maanantaiaamuna käyttäjäpalaute heikkenee, kukaan ei tiedä, mikä malli on todella ajossa tai mitä dataa se on tuottanut, ja tiimi käyttää päivän tietojen rekonstruointiin, jotka muutaman rivin tiedosto olisi säilyttänyt.
Versioiden nimeäminen
Hienosäätötyön suffix-parametri on ensimmäinen jäljitettävyytesi työkalu: siihen sijoittamasi merkkijono päätyy mallin lopulliseen tunnisteeseen ja pysyy luettavana kaikkialla – lokeissasi, konfiguraatiossasi ja konsolissasi. Omaksu käytäntö ja pidä siitä kiinni.
# Käytäntö: {nimi}-v{pääversio}.{alamuutos}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Itse numeron on kannettava informaatiota, eikä sen tule olla pelkkä yrityslaskuri. Pääversio muuttuu, kun mallin luonne muuttuu; alaversio, kun parannat mallia rikkomatta toimivuutta. Konkreettisesti datasäätö samoilla hyperparametreilla pysyy samassa pääversiossa, kun taas pohjamallin vaihto vaatii uuden version aloittamista.
| Versio | Mitä se signaloi |
|---|---|
| v1.0 | Ensimmäinen tuotannossa validoitu malli |
| v1.1 | Datasäätö (samat hyperparametrit) |
| v2.0 | Pohjamallin tai strategian vaihto |
| v2.1 | Hyperparametrien säätö |
Mallirekisterin ylläpito
Pelkkä nimi ei riitä: se ei kerro mitään datasarjan sisällöstä, saavutetuista tuloksista tai siitä, miksi tämä versio nostettiin tuotantoon. Keskitetty rekisteri pitää nämä metatiedot teknisen tunnisteen rinnalla ja toimii tiimisi ainoana totuudenlähteenä. Alla oleva luokka pitää oleelliset tiedot JSON-tiedostossa: se kirjaa ehdokasmallin, ylennää yhden tuotantoon merkiten edellisen eläkkeelle, palauttaa parhaillaan aktiivisen tunnisteen ja näyttää historian. Käytä aikaa notes-kentän täyttämiseen: yksi lause siitä, mitä edelliseen versioon verrattuna on muuttunut, säästää sinut myöhemmin puolen päivän arkeologialta.
import json
import datetime
class ModelRegistry:
"""Hienosäädettyjen mallien rekisteri."""
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 = ""
):
"""Kirjaa uuden mallin rekisteriin."""
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):
"""Ylentää mallin tuotantoon."""
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):
"""Palautus edelliseen versioon."""
self.promote(version)
print(f"Rollback performed to {version}")
def production_model(self) -> str:
"""Palauttaa tuotannossa olevan mallin tunnisteen."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Näyttää mallihistorian."""
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)
Käytännössä version elinkaari tiivistyy kolmeen kutsuun: kirjaat mallin valmistuttua sen lukujen kera, yennät sen tuotantoon, kun arviointi vahvistaa sen, ja palaat edelliseen versioon, jos tuotanto on ristiriidassa arvioinnin kanssa. Tämän viimeisen rivin tulee olla yhtä triviaali kirjoittaa kuin kahden ensimmäisenkin.
registry = ModelRegistry()
# Kirjaa uusi malli
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"
)
# Ylennä tuotantoon
registry.promote("v2.1")
# Ongelmatilanteessa palautus
registry.rollback("v2.0")
Palautus sekunneissa
Palautus on arvokas vain, jos se on nopea eikä vaadi pohdintaa. Koska sovelluksesi lukee mallin nimen ympäristömuuttujasta, versioiden vaihtaminen tarkoittaa kyseisen muuttujan muuttamista ja rekisterin päivittämistä – ei koodin uudelleenkäyttöönottoa, ei uudelleenkääntämistä. quick_rollback-funktio menee pidemmälle ohittamalla inhimillisen valinnan kokonaan: se poimii viimeisimmän käytettävissä olevan vakaan version ja, jos sellaista ei ole, palaa pohjamalliin. Tämä viimeinen haara on ehdoton varaverkkosi; laukaise se tahallisesti kerran testiympäristössä, kun panokset ovat nolla.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Ottaa mallin käyttöön päivittämällä ympäristömuuttujan."""
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")
# Päivitä konfiguraatio
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):
"""Palautus viimeisimpään vakaaseen versioon."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Varavaihtoehto: pohjamalli
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)
Arkistoi data, älä vain malleja
Mallin versioiminen ilman sitä tuottaneen datan versiointia vie sinut vain puolimatkaan. Sinä päivänä, kun haluat ymmärtää, miksi v2.1 piti yllä tyyliä paremmin kuin v2.2, tarvitset täsmälleen ne kolme tiedostoa, joita sen kouluttamiseen käytettiin, testijoukon mukaan lukien – ilman sitä mikään myöhempi vertailu ei ole reilua. Arkistoi ne versionumeroa kantavaan kansioon juuri sillä hetkellä, kun kirjaat mallin.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Arkistoi koulutusdatan tietylle versiolle."""
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"
)
Automatisoi koko putki
Nämä käsin suoritetut vaiheet jäävät lopulta väliin – erityisesti arkistointi, joka tulee viimeisenä eikä estä mitään. Kokoa ne yhdeksi skriptiksi, joka ketjuttaa tiedostojen latauksen, työn käynnistyksen, odotuksen valmistumiseen, kirjaamisen rekisteriin ja lopuksi datan arkistoinnin. Odotussilmukka kysyy työn tilaa joka kolmassekunti ja pysähtyy lopulliseen tilaan; virhetilanteessa funktio palautuu välittömästi sen sijaan, että jatkaisi olemattomalla mallilla.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Koko putki: lataus, koulutus, arviointi, kirjaus."""
client = OpenAI()
registry = ModelRegistry()
# 1. Lataus
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. Koulutus
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. Odota valmistumista
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. Kirjaus
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. Arkistoi data
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline complete: {job.fine_tuned_model}")
return job.fine_tuned_model
Siivous
Hienosäädetyt mallit tallennetaan OpenAI:hon ja ne voidaan poistaa, kun niitä ei enää tarvita. Tusinan iteraation jälkeen lista muuttuu lukukelvottomaksi ja manuaalinen lajittelu vaaralliseksi. Alla oleva automaattinen siivous pitää tallessa kolme uusinta versiota eikä koske koskaan tuotannossa olevaan malliin. Vältä liian aggressiivista toimintaa: juuri toiseksi viimeinen versio, jota usein pidetään hyödyttömänä, pelastaa sinut palautustilanteessa.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Poistaa vanhoja malleja pitäen tallessa viimeiset N kappaletta."""
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}")
Keskeiset asiat
- Käytä versioituja päätteitä kunkin mallin tunnistamiseen
- Ylläpidä keskitettyä rekisteriä, jossa on mittareita ja metadataa
- Toteuta nopea palautusmekanismi
- Arkistoi koulutusdata jokaisen version yhteydessä
- Automatisoi putki ja siivoa vanhat mallit säännöllisesti: vähemmän inhimillisiä virheitä, vähemmän tarpeettomia kustannuksia
Testaa tietämyksesi
Ennen malliesi versiointia valido koko hienosäätösykli.
1. Milloin hienosäätö on oikea työkalu – ja milloin ei?
Vastaus: Hyvä tyylisuunnan, muodon tai toistuvan käyttäytymisen ankkurointiin, jota kehotteet (prompting) eivät saavuta luotettavasti; huono tuoreen tiedon syöttämiseen – se on RAG:n tehtävä.
2. Mikä tekee koulutusaineistosta laadukasta?
Vastaus: Puhtaat, johdonmukaiset ja edustavat esimerkit keskustelumuotoisessa JSONL-muodossa: muutama sata erinomaista esimerkkiä voittaa tuhannet kohinaiset.
3. Mitä DPO tuo verrattuna valvottuun hienosäätöön?
Vastaus: Preferenssioppimisen: tarjoat hyväksytty/hylätty-vastauspareja, ja malli oppii “paremman” eikä pelkkää jäljittelyä – hyödyllistä sävyn ja hienovaraisten kompromissien kannalta.
4. Miten validoit hienosäädetyn mallin?
Vastaus: Vertaamalla sitä pohjamalliin arviointijoukolla, joka on pidetty erillään koulutuksesta, ja sen jälkeen A/B-testauksella liiketoimintamittareilla – ei koskaan pelkän vaikutelman perusteella.
5. Miksi versioita ja suunnitella palautusta?
Vastaus: Jokainen hienosäätö tuottaa päivätyn mallin: regressiotilanteessa tuotannossa vaihat takaisin edelliseen versioon välittömästi – mallia hallitaan kuin koodia.
Puhdas data, rehellinen arviointi, hallitut versiot: hienosäätö on insinööritaidetta – tämä kurssi on antanut sinulle koko syklin.