Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Versionēšana un atgriešanās iepriekšējā versijā

Nodarbība 16 no 16 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Kāpēc versijot savus modeļus
  2. Versiju nosaukumu veidošana
  3. Modeļu reģistra uzturēšana
  4. Atgriešanās iepriekšējā versijā sekundēs
  5. Arhivē datus, ne tikai modeļus
  6. Automatizē pilnu cauruļvadu
  7. Tīrīšana
  8. Galvenās atziņas
  9. Pārbaudi savas zināšanas

Atjauninājums: 2026. gada 2. novembris — Smalkās noregulēšanas pieejamība. OpenAI pašapkalpošanās smalkā noregulēšana tiek pakāpeniski pārtraukta: kopš 2026. gada 7. maija organizācijas, kas to nekad nav izmantojušas, vairs nevar izveidot uzdevumus; kopš 2. jūlija jums ir jābūt izmantojušam smalki noregulētu modeli pēdējo 60 dienu laikā; un sākot ar 2027. gada 6. janvāri, neviens klients nevarēs uzsākt jaunus uzdevumus. Jau apmācītie modeļi paliek lietojami, līdz tiek izslēgts to bāzes modelis. Šis kurss joprojām ir noderīgs, lai saprastu un izmantotu esošu modeli; jauniem projektiem dodiet priekšroku uzvedņu inženierijai, RAG un novērtējumiem.

Kāpēc versijot savus modeļus

Darbvidē jūs iterēsit savu smalki noregulēto modeli: jauni dati, pielāgoti hiperparametri, jauns bāzes modelis. Bez stingras versiju kontroles sistēmas jūs zaudēsiet izsekojamību un spēju atgriezties iepriekšējā stāvoklī regresijas gadījumā. Scenārijs vienmēr ir vienāds: pirmdienas rītā lietotāju atsauksmes pasliktinās, neviens nezina, kurš modelis faktiski darbojas vai kādi dati to ģenerējuši, un komanda pavada dienu, rekonstruējot informāciju, ko dažas koda rindiņas failā būtu saglabājušas.

Versiju nosaukumu veidošana

Smalkās noregulēšanas uzdevuma parametrs suffix ir jūsu pirmais izsekojamības rīks: virkne, ko tur ievietojat, nonāk modeļa gala ID un palasa lasāma visur — jūsu žurnālos, konfigurācijā, konsolē. Pieņemiet konvenciju un pieturieties pie tās.

# Konvencija: {nosaukums}-v{lielā_versija}.{mazā_versija}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

Skaitlim pašam ir jānes informācija, ne tikai jāsaskaita mēģinājumi. Lielā versija mainās, kad mainās modeļa būtība; mazā versija, kad veicat uzlabojumus, nelaužot funkcionalitāti. Konkrēti, datu labojums, kas piemērots ar tiem pašiem hiperparametriem, paliek tajā pašā lielajā versijā, savukārt bāzes modeļa maiņa prasa sākt jaunu.

VersijaKo tā signalizē
v1.0Pirmais modelis, kas apstiprināts darbvidē
v1.1Datu labojums (tie paši hiperparametri)
v2.0Bāzes modeļa vai stratēģijas maiņa
v2.1Hiperparametru pielāgošana

Modeļu reģistra uzturēšana

Ar nosaukumu vien nepietiek: tas neko nesaka par to, kas bija datu kopā, kādi rezultāti iegūti vai kāpēc šī versija tika paaugstināta. Centralizēts reģistrs glabā šos metadatus līdztekus tehniskajam ID un kļūst par jūsu komandas vienīgo patiesības avotu. Tālāk redzamā klase saglabā būtisko JSON failā: tā reģistrē kandidātmodeli, paaugstina vienu uz darbvidi, atzīmējot iepriekšējo kā izslēgtu, atgriež pašlaik aktīvo ID un parāda vēsturi. Velti laiku, lai aizpildītu lauku notes: viens teikums par to, kas mainījies kopš iepriekšējās versijas, vēlāk ietaupīs pusdienu arheoloģijas darbu.

import json
import datetime

class ModelRegistry:
    """Smalki noregulētu modeļu reģistrs."""

    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 = ""
    ):
        """Reģistrē jaunu modeli reģistrā."""
        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"Modelis {version} reģistrēts: {model_id}")

    def promote(self, version: str):
        """Paaugstina modeli uz darbvidi."""
        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"Darbvide: {old} -> {version}")

    def rollback(self, version: str):
        """Atgriežas iepriekšējā versijā."""
        self.promote(version)
        print(f"Veikta atgriešanās uz {version}")

    def production_model(self) -> str:
        """Atgriež darbvidē esošā modeļa ID."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Parāda modeļu vēsturi."""
        print(f"{'Versija':<12} {'Statuss':<12} {'Datums':<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)

Praksē versijas dzīves cikls reducējas uz trim izsaukumiem: jūs reģistrējat modeli, kas nāk no apmācības, ar tā rādītājiem; jūs to paaugstināt, kad novērtējums to apstiprina; un jūs atgriežaties iepriekšējā versijā, ja darbvide pretrunā novērtējumam. Šai pēdējai rindiņai ir jābūt tikpat triviālai uzrakstīšanai kā pirmajām divām.

registry = ModelRegistry()

# Reģistrē jaunu modeli
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="Pievienoti 50 labojumu piemēri atmaksām"
)

# Paaugstina uz darbvidi
registry.promote("v2.1")

# Grūtību gadījumā atgriežas iepriekšējā versijā
registry.rollback("v2.0")

Atgriešanās iepriekšējā versijā sekundēs

Atgriešanās iepriekšējā versijā ir vērtīga tikai tad, ja tā ir ātra un neprasa domāšanu. Tā kā jūsu lietotne nolasa modeļa nosaukumu no vides mainīgā, versijas maiņa nozīmē šī mainīgā nomaiņu un reģistra atjaunināšanu — nav nepieciešama koda izvietošana vai atkārtota kompilācija. Funkcija quick_rollback iet tālāk, pilnībā apejot cilvēka izvēli: tā paņem pēdējo pieejamo stabilo versiju un, ja tāda nav, atgriežas pie bāzes modeļa. Šis pēdējais zars ir jūsu absolūtais drošības tīkls; izsauciet to brīvprātīgi vienu reizi testa vidē, kamēr likmes ir nulles.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Izvieto modeli, atjauninot vides mainīgo."""
    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"Versija {version} nav atrasta")

    # Atjaunina konfigurāciju
    os.environ["OPENAI_FT_MODEL"] = model_id
    registry.promote(version)

    print(f"Modelis izvietots: {version} ({model_id})")
    return model_id

def quick_rollback(registry: ModelRegistry):
    """Atgriežas pēdējā stabilajā versijā."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Atgriežas pie bāzes modeļa
        os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
        print("Atgriešanās pie bāzes modeļa")
        return

    last_stable = versions[-1]
    deploy_model(last_stable["version"], registry)

Arhivē datus, ne tikai modeļus

Modeļa versiju kontrole, neversijojot to, kas to radīja, aizved jūs tikai līdz pusei ceļa. Dienā, kad vēlēsities saprast, kāpēc v2.1 noturēja toni labāk nekā v2.2, jums būs nepieciešami tieši trīs faili, kas izmantoti tā apmācībai, ieskaitot testa kopu — bez tās neviena turpmāka salīdzināšana nav godīga. Arhivējiet tos mapē, kas nes versijas numuru, tieši tajā brīdī, kad reģistrējat modeli.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Arhivē apmācības datus konkrētai versijai."""
    folder = f"{archive_folder}/{version}"
    os.makedirs(folder, exist_ok=True)

    for file in files:
        shutil.copy2(file, folder)

    print(f"Dati arhivēti mapē {folder}")

archive_dataset(
    "v2.1",
    ["train.jsonl", "validation.jsonl", "test.jsonl"],
    "archives/datasets"
)

Automatizē pilnu cauruļvadu

Šie soļi, izpildīti ar roku, laika gaitā tiek izlaisti — īpaši arhivēšana, kas nāk pēdējā un neko nebloķē. Apvienojiet tos vienā skriptā, kas secīgi veic failu augšupielādi, uzdevuma uzsākšanu, gaidīšanu līdz pabeigšanai, reģistrēšanu reģistrā un pēc tam datu arhivēšanu. Gaidīšanas cikls vaicā uzdevumu ik pēc trīsdesmit sekundēm un apstājas pie gala statusa; kļūmes gadījumā funkcija atgriežas uzreiz, nevis turpina darbu ar neesošu modeli.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Pilns cauruļvads: augšupielāde, apmācība, novērtēšana, reģistrēšana."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Augšupielāde
    print("Datu augšupielāde...")
    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. Apmācība
    print("Smalkās noregulēšanas uzsākšana...")
    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. Gaidīšana līdz pabeigšanai
    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"Kļūme: {job.error}")
        return None

    # 4. Reģistrēšana
    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. Datu arhivēšana
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

    print(f"Caurlaide pabeigta: {job.fine_tuned_model}")
    return job.fine_tuned_model

Tīrīšana

Smalki noregulēti modeļi tiek glabāti OpenAI un tos var dzēst, kad tie vairs nav nepieciešami. Pēc ducim iterāciju saraksts kļūst nelasāms, un manuāla šķirošana — bīstama. Tālāk redzamā automātiskā tīrīšana saglabā trīs jaunākās versijas un nekad nepieskaras tai, kas darbojas darbvidē. Izvairieties būt pārāk agresīviem: tieši priekšpēdējā versija, ko bieži uzskata par bezjēdzīgu, jūs izglābs atgriešanās laikā iepriekšējā versijā.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Dzēš vecos modeļus, saglabājot pēdējos 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"Dzēsts: {m['version']} ({m['model_id']})")
        except Exception as e:
            print(f"Kļūda, dzēšot {m['version']}: {e}")

Galvenās atziņas

  • Izmantojiet versijotus sufiksus, lai identificētu katru modeli
  • Uzturiet centralizētu reģistru ar metrikām un metadatiem
  • Ieviesiet ātru mehānismu atgriešanai iepriekšējā versijā
  • Arhivējiet apmācības datus kopā ar katru versiju
  • Automatizējiet cauruļvadu un regulāri attīriet vecos modeļus: mazāk cilvēka kļūdu, mazāk lieku izmaksu

Pārbaudi savas zināšanas

Pirms modeļu versiju kontroles uzsākšanas validē pilnu smalkās noregulēšanas ciklu.

1. Kad smalkā noregulēšana ir pareizais rīks — un kad tā nav?

Atbilde: Laba stila, formāta vai atkārtotas uzvedības nostiprināšanai, ko uzvednes nenodrošina uzticami; slikta jaunu zināšanu ievadīšanai — tas ir RAG uzdevums.

2. Kas padara apmācības datu kopu augstas kvalitātes?

Atbilde: Tīri, konsekventi un reprezentatīvi piemēri sarunu JSONL formātā: daži simti izcilu piemēru pārspēj tūkstošiem trokšņainu.

3. Ko DPO sniedz salīdzinājumā ar uzraudzītu smalko noregulēšanu?

Atbilde: Preferenču mācīšanos: jūs nodrošināt vēlamu/noraidītu atbilžu pārus, un modelis mācās „labāku”, nevis vienkāršu imitāciju — noderīgi tonim un smalkiem kompromisiem.

4. Kā validēt smalki noregulētu modeli?

Atbilde: Salīdzinot to ar bāzes modeli novērtējuma kopā, kas turēta atsevišķi no apmācības, un pēc tam veicot A/B testēšanu uz biznesa metrikām — nekad tikai uz iespaida balstoties.

5. Kāpēc versijot un plānot atgriešanos iepriekšējā versijā?

Atbilde: Katra smalkā noregulēšana rada datētu modeli: regresijas gadījumā darbvidē jūs uzreiz pārslēdzaties uz iepriekšējo versiju — modelis tiek pārvaldīts tāpat kā kods.

Tīri dati, godīga novērtēšana, kontrolētas versijas: smalkā noregulēšana ir inženierijas disciplīna — šis kurss ir devis jums pilnu ciklu.