L-Ispejżej u l-Ottimizzazzjoni
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.
Kif Tifhem l-Istruttura tal-Ispejżej
Il-fine-tuning ta’ OpenAI jinvolvi żewġ tipi ta’ spiżej: spiża ta’ darba għat-taħriġ u spiża kontinwa għall-inferenza. Li tifhimhom u tottimizzahom huwa essenzjali għal implimentazzjoni profittabbli. Id-distinzjoni mhijiex biss kontabbli: l-ewwel spiża hija deċiżjoni ta’ darba meħuda qabel tniedi x-xogħol, u ma tbiddilx; it-tieni ġġorrlek kull xahar u tikber mat-traffiku tiegħek. Tim li jiffjuda fuq l-ispejżej tat-taħriġ u ħallieħ prompt ta’ elf token idur fuq ħamest elef talba kuljum ikun qiegħed jiġġiebed fil-battalja żbaljata.
L-Ispejża tat-Taħriġ
It-taħriġ jiġi ffatturat għal kull token ipproċessat, u dak l-ammont jiddependi direttament minn żewġ varjabbli li jinsabu f’idejk: id-daqs tad-dataset tiegħek u n-numru ta’ darbiet li tgħaddi minnu.
Training cost = total_tokens × number_epochs × price_per_training_token
Din il-formola tippermettilek tistma l-fattura qabel ma tniedi xejn. Il-funzjoni t’hawn taħt tiċċekkja l-fajl JSONL u toqrob l-għadd ta’ tokens skont it-tul tal-messaġġi — l-istima ta’ token wieħed kull erba’ karattri bil-Franċiż hija approssimattiva, imma biex tiddistingwi xogħol ta’ ftit dollari minn wieħed ta’ mijiet, hi biżżejjed. Daħħal fid-drawwa li ħaddimha b’mod sistematiku: żball fit-tħejjija li jtla’ t-tliet darbiet id-dataset jidher minnufih fir-riżultat.
import json
def estimate_training_cost(
jsonl_file: str,
n_epochs: int,
price_per_million_tokens: float
) -> dict:
"""Estimates training cost before launching the job."""
total_tokens = 0
with open(jsonl_file, "r") as f:
num_examples = 0
for line in f:
num_examples += 1
obj = json.loads(line)
for msg in obj["messages"]:
# Rough estimate: 1 token ~ 4 characters in French
total_tokens += len(msg["content"]) // 4
training_tokens = total_tokens * n_epochs
cost = training_tokens * price_per_million_tokens / 1_000_000
return {
"examples": num_examples,
"tokens_per_pass": total_tokens,
"epochs": n_epochs,
"total_tokens": training_tokens,
"estimated_cost": f"${cost:.2f}"
}
result = estimate_training_cost(
"training_data.jsonl",
n_epochs=3,
price_per_million_tokens=8.0 # check current pricing
)
for k, v in result.items():
print(f"{k}: {v}")
L-Ispejża tal-Inferenza
L-inferenza tiġi ffatturata għal kull sejħa, skont it-tokens tad-dħul u tal-ħruġ, u l-mudelli fine-tuned ġeneralment ikollhom rata ftit ogħla mill-mudell bażi. Din iż-żieda fil-prezz unitarju ħafna drabi ġġib dubji, u bla bażi: tapplika għal ħafna inqas tokens, peress li l-imġiba li qabel kienet deskritta f’system prompt twil issa tkun diġà inkorporata fil-mudell. Il-kalkolu t’hawn taħt ipoġġi ż-żewġ xenarji ġenb ma’ ġenb għal xahar ta’ traffiku identiku, bi prompt li jinżel minn 800 għal 100 token kontra rati ddruppljati. Aġġusta l-parametri bin-numri tiegħek qabel tasal għal konklużjonijiet: għal użu fejn il-prompt diġà kien qasir, it-trade-off jinqaleb.
def monthly_cost(
requests_per_day: int,
avg_input_tokens: int,
avg_output_tokens: int,
price_input_per_million: float,
price_output_per_million: float
) -> float:
"""Calculates monthly inference cost."""
requests_month = requests_per_day * 30
input_cost = requests_month * avg_input_tokens * price_input_per_million / 1_000_000
output_cost = requests_month * avg_output_tokens * price_output_per_million / 1_000_000
return input_cost + output_cost
# Scenario: base model with long prompt
base_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=800, # long system prompt + question
avg_output_tokens=200,
price_input_per_million=0.15,
price_output_per_million=0.60
)
# Scenario: fine-tuned model with minimal prompt
ft_cost = monthly_cost(
requests_per_day=5000,
avg_input_tokens=100, # short prompt, behavior integrated
avg_output_tokens=200,
price_input_per_million=0.30, # higher FT rate
price_output_per_million=1.20
)
print(f"Monthly base cost: ${base_cost:.2f}")
print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
print(f"Difference: ${ft_cost - base_cost:+.2f}")
Naqqas it-Tokens tad-Dħul
Il-lieva prinċipali għall-iffrankar b’mudell fine-tuned hija t-tnaqqis tal-prompt. Kull struzzjoni li tirnexxiellek tneħħi għax il-mudell diġà ġarrfha hija gwadann li jiġi ripetut fuq kull sejħa, sakemm is-servizz jilħaq it-tmiem ħajtu. It-tabella t’hawn taħt tagħti l-ordnijiet ta’ kobor osservati skont il-grad ta’ inkorporazzjoni milħuq.
| Approċċ | Tokens tad-dħul | Ffrankar |
|---|---|---|
| Mudell bażi + prompt dettaljat | 500-1000 tokens | Referenza |
| Fine-tuned + prompt minimu | 50-100 tokens | 80-90% fuq id-dħul |
| Fine-tuned + bla system prompt | 20-50 tokens | 95% fuq id-dħul |
Tneħħilhomx l-istruzzjonijiet kollha f’daqqa u ttenna li kollox jinżamm. Neħħihom f’gruppi, u erġa’ ġġibed is-sett ta’ testijiet wara kull tneħħija: se tikxef li ċerti regoli ġew imħarrġa perfettament waqt li oħrajn, inqas rappreżentati fl-eżempji tiegħek, iridu jibqgħu fil-prompt.
Ibbilanċja d-Daqs tad-Dataset mal-Epochs
Aktar data tagħti mudell aħjar, imma wkoll spiża ta’ taħriġ ogħla, u l-gwadann jonqos bil-mod. Minn mija eżempju sa tliet mija normalment ibiddel ħafna; minn elf sa tliet elef ibiddel ftit, għal tliet darbiet il-prezz. Ħarreġ daqsijiet differenti, kejjel il-kwalità miksuba, u qabblha mal-ispiża biex issib il-punt ta’ ekwilibriju tiegħek.
def find_optimal(results_by_size: dict):
"""Identifies the optimal dataset size."""
print("Dataset size | Quality score | Training cost")
print("-" * 55)
best_ratio = 0
optimal_size = 0
for size, data in sorted(results_by_size.items()):
score = data["score"]
cost = data["cost"]
ratio = score / cost if cost > 0 else 0
print(f"{size:>14} | {score:>13.2f} | {cost:>17.2f} $")
if ratio > best_ratio:
best_ratio = ratio
optimal_size = size
print(f"\nOptimal size: {optimal_size} examples")
Anke l-għażla tal-mudell bażi tiżen fuq l-istess miżura. Luna huwa inqas għoli minn Terra, kemm fit-taħriġ kif ukoll fl-inferenza: dejjem ibda bil-mudell l-aktar irħis u telgħ biss jekk il-kwalità miksuba ma tkunx biżżejjed. Iċċekkja liema mudelli huma eliġibbli għall-fine-tuning fid-dokumentazzjoni ta’ OpenAI — il-lista tinbidel ma’ kull ġenerazzjoni u qatt ma tkopri l-katalogu kollu. Imbagħad hemm in-numru ta’ epochs, peress li kull pass żejjed jimmultiplika mekkanikament l-ispiża tat-taħriġ. Jekk 2 epochs jagħtuk 95% tal-kwalità ta’ 4 epochs, l-għażla ssir malajr.
Immonitorja l-Infiq f’Produzzjoni
L-istima magħmula qabel it-tnedija tapplika biss għat-taħriġ. F’produzzjoni, huwa t-traffiku reali li jmexxi l-ispejżej, u ħafna drabi l-fattura tikser l-aspettattivi ‘l fuq. Kontatur li jiżdied minn kull sejħa, marbut ma’ baġit xahuri, jgħarrak qabel il-fattura nnifisha. Il-limitu ta’ 80% iħallik il-ħin biex taġixxi: naqqas prompt, limitat it-tul tat-tweġibiet, jew ċaqlaq parti mit-traffiku lejn mudell aktar irħiż.
class CostTracker:
"""Real-time cost tracking."""
def __init__(self, monthly_budget: float):
self.budget = monthly_budget
self.spending = 0.0
self.calls = 0
def record(self, input_tokens: int, output_tokens: int,
input_price: float, output_price: float):
"""Records the cost of a call."""
cost = (
input_tokens * input_price / 1_000_000 +
output_tokens * output_price / 1_000_000
)
self.spending += cost
self.calls += 1
# Alert if approaching budget
utilization = self.spending / self.budget * 100
if utilization > 80:
print(f"ALERT: {utilization:.1f}% of monthly budget used")
def report(self):
"""Consumption report."""
print(f"Calls: {self.calls}")
print(f"Spending: ${self.spending:.2f}")
print(f"Remaining budget: ${self.budget - self.spending:.2f}")
if self.calls > 0:
print(f"Average cost per call: ${self.spending / self.calls:.4f}")
Kif Tiġġustifika l-Investiment
Tibqa’ l-mistoqsija li l-maniġment tiegħek se jagħmillek aktar tard: kemm iddum biex it-taħriġ iħallas ruħu lura? Il-kalkolu jqabbel spiża ta’ darba ma’ benefiċċju xahuri, li jgħodd flimkien l-iffrankar tat-tokens u l-valur li tagħti lill-gwadann fil-kwalità. It-tieni terminu huwa l-aktar delikat, u aħjar tħallih żero milli tinventah: payback ippruvat fuq iffrankar imkejjel biss jaqta’ aktar minn projezzjoni ġeneruża.
def calculate_roi(
training_cost: float,
monthly_savings: float,
quality_gain_value: float = 0
) -> dict:
"""Calculates the return on investment for fine-tuning."""
monthly_benefit = monthly_savings + quality_gain_value
payback_months = training_cost / monthly_benefit if monthly_benefit > 0 else float("inf")
return {
"training_cost": f"${training_cost:.2f}",
"monthly_benefit": f"${monthly_benefit:.2f}",
"payback": f"{payback_months:.1f} months",
"annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
}
Punti Ewlenin
- Ikkalkula l-ispiża tat-taħriġ qabel ma tniedi x-xogħol
- Il-lieva prinċipali għall-iffrankar hija t-tnaqqis tat-tokens tad-dħul
- Ibda bil-mudell bażi l-aktar irħiż (Luna) qabel ma titla’ għal Terra
- Immonitorja l-ispejżej f’produzzjoni b’alerta fuq il-baġit
- Ikkalkula l-ROI inklużi l-gwadann fil-kwalità u l-iffrankar tat-tokens