Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Versionimine ja taastamine

Õppetund 16 / 16 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Miks oma mudeleid versioonida
  2. Versioonide nimetamine
  3. Mudeliregistri haldamine
  4. Taastamine sekunditega
  5. Arhiveeri andmed, mitte ainult mudelid
  6. Automatiseeri kogu torustik
  7. Puhastamine
  8. Peamised punktid
  9. Testi oma teadmisi

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.

VersioonMida see annab märku
v1.0Tootmises kinnitatud esimene mudel
v1.1Andmete parandus (samad hüperparameetrid)
v2.0Baasmudeli või strateegia vahetus
v2.1Hü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.