Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Versionointi ja palautus

Oppitunti 16 / 16 Päivitetty 2. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Miksi malleja kannattaa versioida
  2. Versioiden nimeäminen
  3. Mallirekisterin ylläpito
  4. Palautus sekunneissa
  5. Arkistoi data, älä vain malleja
  6. Automatisoi koko putki
  7. Siivous
  8. Keskeiset asiat
  9. Testaa tietämyksesi

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.

VersioMitä se signaloi
v1.0Ensimmäinen tuotannossa validoitu malli
v1.1Datasäätö (samat hyperparametrit)
v2.0Pohjamallin tai strategian vaihto
v2.1Hyperparametrien 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.