Verżjonijiet u Rollback
F'din il-paġna
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żjoni | X’tindika |
|---|---|
| v1.0 | L-ewwel mudell ivvalidat fil-produzzjoni |
| v1.1 | Tiswija tad-data (l-istess iperparametri) |
| v2.0 | Bidla fil-mudell bażi jew fl-istrateġija |
| v2.1 | Aġġ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ħ.