Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Verżjonijiet u Rollback

Lezzjoni 16 / 16 Aġġornat 2 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Għaliex Tivverżjona l-Mudelli Tiegħek
  2. Kif Tagħti Isimhom lill-Verżjonijiet
  3. Kif Iżomm Reġistru tal-Mudelli
  4. Rollback f’Sekondi
  5. Arkivja d-Data, Mhux Biss il-Mudelli
  6. Awtomatizza l-Pipeline Sħiħ
  7. Tindif
  8. Punti Ewlenin
  9. Ittestja l-Għarfien Tiegħek

Aġġornament tat-2 ta’ Novembru 2026 — Disponibbiltà tal-fine-tuning. Il-fine-tuning self-service ta’ OpenAI qed jitneħħa bil-mod: mill-7 ta’ Mejju 2026, organizzazzjonijiet li qatt ma użawh ma jistgħux jibqgħu joħolqu xogħlijiet ta’ taħriġ ġodda; mill-2 ta’ Lulju, trid tkun użajt mudell fine-tuned fl-aħħar 60 jum; u mill-6 ta’ Jannar 2027, l-ebda klijent ma jkun jista’ jneddi xogħlijiet ġodda. Mudelli diġà mħarrġa jibqgħu użabbli sakemm il-mudell bażi tagħhom jiġi rtirat. Dan il-kors jibqa’ utli biex tifhem u tisfrutta mudell eżistenti; għal proġetti ġodda, agħti prijorità lill-inġinerija tal-prompt, lir-RAG u lill-evalwazzjonijiet.

Għaliex Tivverżjona l-Mudelli Tiegħek

F’produzzjoni, ser tipprova u ttejjeb il-mudell fine-tuned tiegħek: data ġdida, iperparametri aġġustati, mudell bażi ġdid. Mingħajr sistema ta’ verżjonar rigoruża, titlef it-traċċabbiltà u l-possibilità li tmur lura f’każ ta’ riġressjoni. Ix-xenarju huwa dejjem l-istess: nhar ta’ Tnejn filgħodu, il-feedback tal-utenti jmur lura, ħadd ma jaf liema mudell qiegħed verament jaħdem jew liema data produċietu, u t-tim iqiedi l-ġurnata jerġa’ jibni informazzjoni li ftit linji f’fajlu kienu ħarsulu.

Kif Tagħti Isimhom lill-Verżjonijiet

Il-parametru suffix tax-xogħol ta’ fine-tuning huwa l-ewwel għodda ta’ traċċabbiltà tiegħek: il-katina li tqiegħed hemm tispiċċa fl-ID finali tal-mudell u tibqa’ tinqara kullimkien—fil-logs tiegħek, fil-konfigurazzjoni, fil-console. Adotta konvenzjoni u aqbad magħha.

# Convention: {name}-v{major_version}.{minor_version}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

In-numru nnifsu għandu jġorr informazzjoni, mhux biss jgħodd il-provi. Verżjoni maġġuri tinbidel meta tinbidel in-natura tal-mudell; verżjoni minuri, meta ttjeb bla ma tkissir. Konkretament, it-tiswija tad-data applikata bl-istess iperparametri tibqa’ fuq l-istess verżjoni maġġuri, filwaqt li bidla fil-mudell bażi titlob li tibda waħda ġdida.

VerżjoniX’tindika
v1.0L-ewwel mudell ivvalidat fil-produzzjoni
v1.1Tiswija tad-data (l-istess iperparametri)
v2.0Bidla fil-mudell bażi jew fl-istrateġija
v2.1Aġġustament tal-iperparametri

Kif Iżomm Reġistru tal-Mudelli

L-isem waħdu mhux biżżejjed: ma jgħidlek xejn dwar x’kien fid-dataset, ir-riżultati miksuba, jew għaliex din il-verżjoni ġiet promossa. Reġistru ċentralizzat iżomm dawn il-metadata ħdejn l-ID tekniku u jsir l-unika sors ta’ verità għat-tim tiegħek. Il-klassi t’hawn taħt iżomm l-essenzjali f’fajl JSON: tirreġistra mudell kandidat, itella’ wieħed fil-produzzjoni waqt li timmarka ta’ qablu bħala rtirat, tipprovdi l-ID attiv bħalissa, u turi l-kronoloġija. Ħu n-nifs biex timla l-kamp notes: senta waħda dwar x’nbiddel mill-verżjoni ta’ qabel ser tħallik nofs ġurnata ta’ arkeoloġija fil-ġejjieni.

import json
import datetime

class ModelRegistry:
    """Registry of fine-tuned models."""

    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 = ""
    ):
        """Records a new model in the registry."""
        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):
        """Promotes a model to production."""
        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):
        """Rollback to a previous version."""
        self.promote(version)
        print(f"Rollback performed to {version}")

    def production_model(self) -> str:
        """Returns the ID of the model in production."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Displays the model history."""
        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)

Fil-prattika, iċ-ċiklu tal-ħajja ta’ verżjoni jinżel fi tliet sejħiet: tirreġistra l-mudell li joħroġ mit-taħriġ bin-numri tiegħu, itella’ meta l-evalwazzjoni tivvalidah, u terġa’ lura għall-verżjoni ta’ qabel jekk il-produzzjoni tikkontradixxi l-evalwazzjoni. Dan it-tielet pass irid ikun banali daqs l-ewwel tnejn biex tiktbu.

registry = ModelRegistry()

# Record a new 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"
)

# Promote to production
registry.promote("v2.1")

# In case of trouble, rollback
registry.rollback("v2.0")

Rollback f’Sekondi

Rollback huwa ta’ valur biss jekk ikun malajr u ma jeħtieġ ebda ħsieb. Peress li l-applikazzjoni tiegħek taqra l-isem tal-mudell minn varjabbli ta’ ambjent, li tbiddel il-verżjonijiet ifisser li tbiddel dik il-varjabbli u li taġġorna r-reġistru—l-ebda ridistribuzzjoni tal-kodiċi, l-ebda rikonpilazzjoni. Il-funzjoni quick_rollback tmur aktar ‘il quddiem billi tevita għal kollox l-għażla umana: tieħu l-aħħar verżjoni stabbli disponibbli u, jekk ma tkunx teżisti, terġa’ lura għall-mudell bażi. Din l-aħħar fergħa hija l-netja ta’ sigurtà assoluta tiegħek; neddiha volontarjament darba f’ambjent ta’ test, fejn ir-riskju huwa żero.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Deploys a model by updating the environment variable."""
    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")

    # Update configuration
    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):
    """Rollback to the last stable version."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Fallback to base model
        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)

Arkivja d-Data, Mhux Biss il-Mudelli

Li tivverżjona mudell mingħajr ma tivverżjona dak li produċah iħallik nofs it-triq. Fil-ġurnata li trid tifhem għaliex v2.1 żammet it-tonu aħjar minn v2.2, ser ikollok bżonn it-tliet fajls eżatti użati għat-taħriġ, sett ta’ test inkluz—mingħajru, l-ebda tqabbil ta’ wara ma jibqa’ ġust. Arkivjahom f’fowlder li ġġorr in-numru tal-verżjoni, fl-eżatt mument li tirreġistra l-mudell.

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Archives training data for a given version."""
    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"
)

Awtomatizza l-Pipeline Sħiħ

Dawn il-passi, meta jitwettqu bl-idejn, fl-aħħar jitħallew barra—speċjalment l-arxivjar, li jiġi fl-aħħar u ma jimblokkax xejn. Ġborhom f’script wieħed li jgħaqqad it-tagħbija tal-fajls, it-tnedija tax-xogħol, it-tmiem tal-istennija, ir-reġistrazzjoni fir-reġistru, u mbagħad l-arxivjar tad-data. Il-linja ta’ stennija terġa’ tistaqsi l-istat tax-xogħol kull tletin sekonda u tieqef fuq status terminali; f’każ ta’ falliment, il-funzjoni tirritorna minnufih minflok tkompli b’mudell li ma jeżistix.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Full pipeline: upload, train, evaluate, record."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Upload
    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. Training
    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. Wait for completion
    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. Record
    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. Archive data
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

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

Tindif

Mudelli fine-tuned jinżammu f’OpenAI u jistgħu jitħassru meta ma għadhomx meħtieġa. Wara għaxar iterazzjonijiet jew aktar, il-lista ssir diffiċli biex tinqara u l-għażla manwali ssir perikoluża. It-tindif awtomatiku t’hawn taħt iżomm it-tliet verżjonijiet l-aktar riċenti u qatt ma jmiss lil dak li qiegħed jaħdem fil-produzzjoni. Evita li tkun agressiv wisq: hija eżattament il-verżjoni ta’ qabel l-aħħar, spiss meqjula inutli, li ser isalvak waqt rollback.

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Deletes old models keeping the last 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}")

Punti Ewlenin

  • Uża suffixes b’verżjoni biex kull mudell ikun identifikabbli
  • Żomm reġistru ċentralizzat b’metriċi u metadata
  • Implimenta mekkaniżmu ta’ rollback malajr
  • Arkivja d-data ta’ taħriġ ma’ kull verżjoni
  • Awtomatizza l-pipeline u naddaf regularly l-mudelli qodma: inqas żbalji umani, inqas spejżej bla bżonn

Ittestja l-Għarfien Tiegħek

Qabel tibda tivverżjona l-mudelli tiegħek, ivverifika ċ-ċiklu sħiħ tal-fine-tuning.

1. Meta l-fine-tuning huwa l-għodda t-tajba—u meta le?

Tweġiba: Tajjeb biex tiżżebbed stil, format jew imġiba rikorrenti li l-prompt waħdu ma jiksbilhomx b’mod affidabbli; ħażin biex tdaħħal għarfien frisk—dak huwa r-rwol tar-RAG.

2. X'jagħmel dataset ta' taħriġ ta' kwalità għolja?

Tweġiba: Eżempji nodja, konsistenti u rappreżentattivi f’format JSONL konversazzjonali: ftit mijiet ta’ eżempji eċċellenti jegħlbu eluf niexfin.

3. X'jżid id-DPO meta mqabbel mal-fine-tuning supervisjonat?

Tweġiba: Tagħlim tal-preferenzi: tipprovdi pari ta’ tweġibiet preferuti/rifjutati, u l-mudell jitgħallem “ahjar” minflok jimita biss—utli għat-tonu u għal trade-offs delikati.

4. Kif tiċċekkja mudell fine-tuned?

Tweġiba: Billi tqabblu mal-mudell bażi fuq sett ta’ evalwazzjoni miżmum separat mit-taħriġ, u mbagħad b’testijiet A/B fuq metriċi tan-negozju—qatt fuq impressjoni biss.

5. Għaliex tivverżjona u tippjana għar-rollback?

Tweġiba: Kull fine-tuning jipproduċi mudell b’data: f’każ ta’ riġressjoni fil-produzzjoni, terġa’ lura għall-verżjoni ta’ qabel minnufih—il-mudell jiġi ġestit bħall-kodiċi.

Data nadifa, evalwazzjoni onesta, verżjonijiet ikkontrollati: il-fine-tuning hu dixxiplina ta’ inġinerija—u dan il-kors tah ċ-ċiklu sħiħ.