Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Versijonavimas ir grįžimas į ankstesnę versiją

Paskaita 16 iš 16 Atnaujinta 2026 m. lapkričio 2 d. Pažengusiems
Šiame puslapyje
  1. Kodėl reikia versijonuoti savo modelius
  2. Versijų pavadinimai
  3. Modelių registro palaikymas
  4. Grįžimas per kelias sekundes
  5. Archyvuok duomenis, o ne tik modelius
  6. Automatizuok visą eigą
  7. Išvalymas
  8. Svarbiausi punktai
  9. Patikrink savo žinias

Atnaujinta 2026 m. lapkričio 2 d. — Derinimo (fine-tuning) prieinamumas. „OpenAI“ savitarnos derinimo paslauga yra nutraukiama: nuo 2026 m. gegužės 7 d. organizacijos, kurios ja niekada nesinaudojo, nebegali kurti užduočių; nuo liepos 2 d. turite būti naudoję derintą modelį per pastaruosius 60 dienų; o nuo 2027 m. sausio 6 d. joks klientas negalės paleisti naujų užduočių. Jau apmokyti modeliai išlieka naudojami, kol jų bazinis modelis bus nutrauktas. Šis kursas vis dar naudingas norint suprasti ir išnaudoti esamą modelį; naujiems projektams teikite pirmenybę raginimų inžinerijai (prompt engineering), RAG ir vertinimams.

Kodėl reikia versijonuoti savo modelius

Gamyboje nuolat tobulinsi savo derintą modelį: nauji duomenys, pakoreguoti hiperparametrai, naujas bazinis modelis. Be griežtos versijonavimo sistemos prarasi galimybę atsekti pokyčius ir grįžti atgal regreso atveju. Scenarijus visada tas pats: pirmadienio rytą vartotojų atsiliepimai pablogėja, niekas nežino, kuris modelis iš tikrųjų veikia ar kokie duomenys jį sukūrė, o komanda visą dieną gaišta bandydama atkurti informaciją, kurią būtų išsaugojęs kelių eilučių failas.

Versijų pavadinimai

Derinimo užduoties parametras suffix yra tavo pirmasis atsekamumo įrankis: čia įrašyta eilutė atsiduria galutiniame modelio ID ir lieka įskaitoma visur – žurnaluose, konfigūracijoje, konsolėje. Susikurk taisyklę ir jos laikykis.

# Taisyklė: {pavadinimas}-v{didžioji_versija}.{mažoji_versija}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

Pats skaičius turi nešti informaciją, o ne tik skaičiuoti bandymus. Didžioji versija keičiama, kai pasikeičia paties modelio pobūdis; mažoji – kai tobulini neveikimo principų. Konkrečiai kalbant, duomenų taisymas taikant tuos pačius hiperparametrus lieka toje pačioje didžiojoje versijoje, o bazinio modelio keitimas reikalauja pradėti naują.

VersijaKą signalizuoja
v1.0Pirmasis gamyboje patvirtintas modelis
v1.1Duomenų taisymas (tie patys hiperparametrai)
v2.0Bazinio modelio arba strategijos keitimas
v2.1Hiperparametrų koregavimas

Modelių registro palaikymas

Vien pavadinimo nepakanka: jis nieko nepasako apie tai, kas buvo duomenų rinkinyje, kokių rezultatų pasiekta ar kodėl ši versija buvo perkelta į gamybą. Centralizuotas registras saugo šiuos metaduomenis šalia techninio ID ir tampa vieninteliu tiesos šaltiniu tavo komandai. Toliau pateikta klasė esminius dalykus saugo JSON faile: ji įrašo kandidatinį modelį, perkelia vieną į gamybą pažymėdama ankstesnį kaip pasenusį, grąžina šiuo metu aktyvų ID ir rodo istoriją. Skirk laiko užpildyti lauką notes: vienas sakinys apie tai, kas pasikeitė nuo ankstesnės versijos, vėliau sutaupys pusę dienos „archeologinių“ kasinėjimų.

import json
import datetime

class ModelRegistry:
    """Derintų modelių registras."""

    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 = ""
    ):
        """Įrašo naują modelį į registrą."""
        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):
        """Perkelia modelį į gamybą."""
        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):
        """Grįžta į ankstesnę versiją."""
        self.promote(version)
        print(f"Rollback performed to {version}")

    def production_model(self) -> str:
        """Grąžina gamyboje esančio modelio ID."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Rodo modelių istoriją."""
        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)

Praktiškai versijos gyvavimo ciklas susiveda į tris kvietimus: įrašai iš mokymų gautą modelį su jo rodikliais, perkeliai jį į gamybą, kai vertinimas tai patvirtina, ir grįžti į ankstesnę versiją, jei gamyba prieštarauja vertinimui. Ši paskutinė eilutė turi būti tokia pat paprasta parašyti kaip ir pirmosios dvi.

registry = ModelRegistry()

# Įrašyti naują 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="Added 50 fix examples for refunds"
)

# Perkelti į gamybą
registry.promote("v2.1")

# Kilus problemoms, grįžti atgal
registry.rollback("v2.0")

Grįžimas per kelias sekundes

Grįžimas į ankstesnę versiją (rollback) turi vertės tik tada, kai jis greitas ir nereikalauja svarstymų. Kadangi tavo programa modelio pavadinimą nusko iš aplinkos kintamojo, versijos keitimas reiškia to kintamojo pakeitimą ir registro atnaujinimą – joks kodo diegimas iš naujo ar perkompiliavimas nereikalingas. Funkcija quick_rollback eina dar toliau, visiškai apeidama žmogaus pasirinkimą: ji pasirenka paskutinę prieinamą stabilią versiją, o jei tokios nėra, grįžta prie bazinio modelio. Ši paskutinė šaka yra tavo absoliutus saugos tinklas; vieną kartą ją sąmoningai suaktyvink testavimo aplinkoje, kol rizika lygi nuliui.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Diegia modelį atnaujinant aplinkos kintamąjį."""
    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")

    # Atnaujinti konfigūraciją
    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):
    """Grįžti į paskutinę stabilią versiją."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Grįžti prie bazinio modelio
        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)

Archyvuok duomenis, o ne tik modelius

Modelio versijonavimas nearchyvuojant to, kas jį sukūrė, yra tik pusė darbo. Tą dieną, kai norėsi suprasti, kodėl v2.1 išlaikė toną geriau nei v2.2, tau prireiks tikslių trijų failų, naudotų jam apmokyti, įskaitant testavimo rinkinį – be jo joks vėlesnis palyginimas nėra sąžiningas. Susarchyvuok juos aplanke, pavadintame versijos numeriu, tuo pačiu momentu, kai įrašai modelį.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Archyvuoja mokymo duomenis konkrečiai versijai."""
    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"
)

Automatizuok visą eigą

Šie žingsniai, vykdomi rankiniu būdu, ilgainiui praleidžiami – ypač archyvavimas, kuris atliekamas paskutinis ir nieko nestabdo. Surink juos į vieną scenarijų, kuris sujungia failų įkėlimą, užduoties paleidimą, laukimą iki pabaigos, įrašymą į registrą ir duomenų archyvavimą. Laukimo ciklas kas trisdešimt sekundžių tikrina užduoties būseną ir sustoja ties galutine būsena; nesėkmės atveju funkcija grąžina rezultatą iškart, o ne tęsia darbą su neegzistuojančiu modeliu.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Pilna eiga: įkėlimas, mokymas, vertinimas, įrašymas."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Įkėlimas
    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. Mokymas
    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. Laukti pabaigos
    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. Įrašymas
    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. Duomenų archyvavimas
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

    print(f"Pipeline complete: {job.fine_tuned_model}")
    return job.fine_tuned_model

Išvalymas

Derinti modeliai saugomi „OpenAI“ ir gali būti ištrinti, kai jų nebenebereikia. Po keliolikos iteracijų sąrašas tampa neįskaitomas, o rankinis rūšiavimas – pavojingas. Toliau pateiktas automatinis išvalymas palieka tris naujausias versijas ir niekada neliečia tos, kuri šiuo metu veikia gamyboje. Venk būti per daug agresyvus: būtent priešpaskutinė versija, dažnai laikoma nenaudinga, tave išgelbės grįžimo atgal metu.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Ištrina senus modelius, paliekant paskutinius 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}")

Svarbiausi punktai

  • Naudok versijuotas pabaigas (suffix), kad identifikuotum kiekvieną modelį
  • Palaikyk centralizuotą registrą su metrikomis ir metaduomenimis
  • Įdiek greitą grįžimo į ankstesnę versiją mechanizmą
  • Archyvuok mokymo duomenis su kiekviena versija
  • Automatizuok visą eigą ir reguliariai valyk senus modelius: mažiau žmogaus klaidų, mažiau nereikalingų išlaidų

Patikrink savo žinias

Prieš pradėdamas versijonuoti savo modelius, patikrink visą derinimo ciklą.

1. Kada derinimas yra tinkamas įrankis, o kada – ne?

Atsakymas: Tinka įtvirtinti stilių, formatą ar pasikartojantį elgesį, kurio raginimai (prompts) patikimai nepasiekia; netinka įdiegti naujų žinių – tam skirtas RAG.

2. Kas daro mokymo duomenų rinkinį aukštos kokybės?

Atsakymas: Švarūs, nuoseklūs ir reprezentatyvūs pavyzdžiai pokalbių JSONL formatu: keli šimtai puikių pavyzdžių yra geriau nei tūkstančiai triukšmingų.

3. Ką DPO suteikia, palyginti su prižiūrimu derinimu?

Atsakymas: Pageidavimų mokymąsi: pateiki pageidaujamų/atmestų atsakymų poras, o modelis mokosi „geriau“, o ne paprasto imitavimo – naudinga tonui ir smulkiems kompromisams.

4. Kaip patvirtini derintą modelį?

Atsakymas: Palygindamas jį su baziniu modeliu vertinimo rinkinyje, atskirtame nuo mokymo, o tada atlikdamas A/B testavimą pagal verslo metrikas – niekada vien pagal įspūdį.

5. Kodėl reikia versijuoti ir numatyti grįžimą atgal?

Atsakymas: Kiekvienas derinimas sukuria datuotą modelį: regresijos gamyboje atveju iškart perjungiamas ankstesnis modelis – modelis valdomas kaip kodas.

Švarūs duomenys, sąžiningas vertinimas, kontroliuojamos versijos: derinimas yra inžinerinė disciplina – šis kursas suteikė tau visą ciklą.