Qabbel mal-Mudell Bażi
F'din il-paġna
Aġġornament 2 ta’ Novembru, 2026 — Disponibbiltà tal-Fine-tuning. Is-servizz awtonomu ta’ fine-tuning ta’ OpenAI qed jiġi rtirat: mill-7 ta’ Mejju, 2026, l-organizzazzjonijiet li qatt ma użawh ma jistgħux joħolqu aktar impjiegi; mit-2 ta’ Lulju, trid tkun użajt mudell imħarreġ b’fine-tuning fl-aħħar 60 jum; u mill-6 ta’ Jannar, 2027, l-ebda klijent ma jkun jista’ jnieda impjiegi ġodda. Il-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, RAG, u l-evalwazzjonijiet.
Għaliex il-paragun sistematiku huwa importanti
Il-fine-tuning għandu spiża: ħin għat-tħejjija tad-data, spejjeż tat-taħriġ, u kumplessità fil-manutenzjoni. Trid tipprova li l-mudell imħarreġ tiegħek jagħti titjib kejl fuq il-mudell bażi b’prompt b’saħħtu. Jekk id-differenza hija marġinali, il-fine-tuning jista’ ma jkunx jiswi l-isforz.
It-tentazzjoni f’dan l-eżerċizzju hija li tqabbel il-mudell imħarreġ tiegħek ma’ mudell bażi mogħti struzzjonijiet ħżiena. Dan joħloq dimostrazzjoni li tfaħħrek iżda bla valur: għelibt avversarju li dgħajjef int stess. L-uniku paragun onest iqiegħed il-mudell imħarreġ tiegħek kontra l-aħjar użu possibbli tal-mudell bażi.
Iddefinixxi l-linja bażi
Il-linja bażi hija l-mudell bażi bl-aħjar system prompt tiegħek. Ottimizza dan il-prompt qabel ma tqabbel. Konkretament, dan ifisser li tikteb ir-regoli li għallimt b’mod impliċitu permezz tal-eżempji waqt il-fine-tuning: ir-rwol, it-ton, it-tul mistenni, u kif tingħalaq skambju. Il-prompt hawn taħt jagħmel eżattament dan għal assistent tas-support; innota li l-mudell imħarreġ b’fine-tuning ma jeħtiġx dawn l-istruzzjonijiet, peress li dawn ir-regoli issa huma parti mill-piżijiet tiegħu.
from openai import OpenAI
client = OpenAI()
OPTIMIZED_SYSTEM_PROMPT = """You are a customer support assistant for TechCorp.
Rules:
- Respond professionally and empathetically
- Always propose a concrete solution
- Limit responses to 3 sentences maximum
- End with a follow-up question"""
def baseline_response(question: str) -> str:
"""Gets a response from the base model."""
response = client.responses.create(
model="gpt-5.6-luna",
instructions=OPTIMIZED_SYSTEM_PROMPT,
input=question
)
return response.output_text
def fine_tune_response(question: str, model_ft: str) -> str:
"""Gets a response from the fine-tuned model."""
response = client.responses.create(
model=model_ft,
input=question
)
return response.output_text
Iġġenera tweġibiet ġenb ma’ ġenb
Il-pass li jmiss huwa li tistaqsi ż-żewġ mudelli bl-istess mistoqsijiet eżatti u żżomm it-tweġibiet appaijati. Agħżel mistoqsijiet rappreżentattivi tat-traffiku reali tiegħek minflok każijiet ta’ kotba: ilment dwar konsenja, talba għal proċedura, nuqqas ta’ sodisfazzjon, talba għal rimbors, mistoqsija fattwali. Dawn il-ħames familji jagħmlu d-differenza fil-produzzjoni, mhux frażijiet perfetti.
import json
def compare_models(
questions: list[str],
base_model: str,
ft_model: str,
system_prompt: str
) -> list[dict]:
"""Compares responses from two models on the same questions."""
comparisons = []
for q in questions:
# Base model with optimized prompt
r_base = client.responses.create(
model=base_model,
instructions=system_prompt,
input=q
)
# Fine-tuned model (minimal or no prompt)
r_ft = client.responses.create(
model=ft_model,
input=q
)
comparisons.append({
"question": q,
"baseline_response": r_base.output_text,
"ft_response": r_ft.output_text
})
return comparisons
# Test questions
test_questions = [
"My package hasn't arrived.",
"How do I reset my password?",
"Your product isn't working as expected.",
"I would like a refund.",
"What are your opening hours?",
]
results = compare_models(
test_questions,
"gpt-5.6-luna",
"ft:gpt-5.6-luna:org::suffix:xxxxxxxx",
OPTIMIZED_SYSTEM_PROMPT
)
Ħalli mudell ta’ parti terza jħaqqem
Il-qari ta’ mijiet ta’ pari bl-idejn malajr isir skoraġġanti, u l-ġudizzju jonqos hekk kif tidħol il-għeja. Mudell ta’ parti terza, li ma pproduċa l-ebda tweġiba, jirbit kull par fuq erba’ kriterji u jagħti verdett globali. L-ewwel, newtralizza t-tikketti: il-ġudici jara “Tweġiba A” u “Tweġiba B”, qatt liema mudell ipproduċihom, inkella l-verdett tiegħu jiżen l-isem tal-mudell daqs it-test. Imbagħad, immaniġġja l-każijiet fejn l-output ma jistax jiġi pproċessat; inkella, tweġiba waħda mħassra twaqqaf il-kampanja kollha.
def judge_comparison(comparison: dict) -> dict:
"""Has a third-party model judge the comparison."""
prompt = f"""Compare these two responses to the same question.
Question: {comparison['question']}
Response A: {comparison['baseline_response']}
Response B: {comparison['ft_response']}
For each criterion, indicate which response is better (A, B, or tie):
1. Relevance of the response
2. Professionalism of tone
3. Adherence to expected format
4. Usefulness to the user
Respond in JSON: {{"relevance": "A/B/tie", "tone": "A/B/tie", "format": "A/B/tie", "usefulness": "A/B/tie", "overall_winner": "A/B/tie"}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=prompt
)
try:
return json.loads(response.output_text)
except json.JSONDecodeError:
return {"error": "Response not parseable"}
# Judge all comparisons
judgments = [judge_comparison(c) for c in results]
Issa aggrega dawn il-verdetti f’figura waħda. Ir-rata ta’ titjib—is-sehem tal-pari fejn il-mudell imħarreġ b’fine-tuning jirbaħ—tiġi mqabbla ma’ limiti definiti minn qabel: ‘il fuq minn 60%, il-maksub huwa ċar; bejn 40% u 60%, qabbel il-maksub mal-ispiża żejda; taħt dan, il-fine-tuning tiegħek ma werax ruħu, u l-problema kważi dejjem tkun fid-data.
def comparison_score(judgments: list[dict]) -> dict:
"""Calculates the overall comparison score."""
scores = {"A_wins": 0, "B_wins": 0, "tie": 0}
for j in judgments:
winner = j.get("overall_winner", "tie")
if winner == "A":
scores["A_wins"] += 1
elif winner == "B":
scores["B_wins"] += 1
else:
scores["tie"] += 1
total = len(judgments)
print(f"Base model wins: {scores['A_wins']}/{total}")
print(f"Fine-tuned model wins: {scores['B_wins']}/{total}")
print(f"Tie: {scores['tie']}/{total}")
improvement_rate = scores["B_wins"] / total * 100
print(f"\nImprovement rate: {improvement_rate:.1f}%")
if improvement_rate >= 60:
print("Fine-tuning provides a significant improvement.")
elif improvement_rate >= 40:
print("Modest improvement—check if the cost is justified.")
else:
print("Fine-tuning does not provide a clear improvement.")
return scores
comparison_score(judgments)
Qabbel l-ispejjeż
Il-kwalità hija biss nofs id-deċiżjoni. Il-fine-tuning spiss inaqqas it-tokens tal-input peress li l-prompt twil isir mhux meħtieġ, iżda kull token fatturat fuq mudell imħarreġ b’fine-tuning jispiża aktar. Dawn iż-żewġ effetti jiġbdu f’direzzjonijiet opposti, u biss il-kalkolu jiddeċiedi. Il-funzjoni hawn taħt tqabblhom ma’ xulxin fuq xahar ta’ traffiku: prompt li jinżel minn 500 għal 50 token jikkumpensa aktar minn rata tal-input irduppjata, iżda dan ma jkunx veru b’prompt bażi diġà qasir.
def compare_costs(
requests_per_day: int,
base_prompt_tokens: int,
ft_prompt_tokens: int,
avg_output_tokens: int,
base_input_price: float,
ft_input_price: float,
output_price: float
):
"""Compares monthly costs between base and fine-tuned models."""
days = 30
base_cost = days * requests_per_day * (
base_prompt_tokens * base_input_price / 1_000_000 +
avg_output_tokens * output_price / 1_000_000
)
ft_cost = days * requests_per_day * (
ft_prompt_tokens * ft_input_price / 1_000_000 +
avg_output_tokens * output_price / 1_000_000
)
savings = base_cost - ft_cost
print(f"Monthly base cost: ${base_cost:.2f}")
print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
print(f"Monthly savings: ${savings:.2f}")
# Example
compare_costs(
requests_per_day=1000,
base_prompt_tokens=500, # long prompt with instructions
ft_prompt_tokens=50, # short prompt, behavior is integrated
avg_output_tokens=200,
base_input_price=0.15,
ft_input_price=0.30, # fine-tuned costs more per token
output_price=0.60
)
Qabbel il-latency
It-tqassir ta’ prompt b’mijiet ta’ tokens jaffettwa wkoll il-ħin ta’ rispons, kriterju li l-utenti tiegħek jinnotawh ferm qabel il-finezza tonali. Kejjel il-latency fuq l-istess mistoqsijiet użati għall-paragun kwalitattiv, barra mill-ħinijiet ta’ quċċata, u erġa’ agħmel il-kejl diversi drabi: valur wieħed jirrifletti l-aktar l-istat tan-netwerk fil-ħin tat-test.
import time
def measure_latency(model: str, questions: list[str], prompt: str = "") -> float:
"""Measures the average latency of a model."""
latencies = []
for q in questions:
start = time.time()
kwargs = {"model": model, "input": q}
if prompt:
kwargs["instructions"] = prompt
client.responses.create(**kwargs)
latencies.append(time.time() - start)
avg = sum(latencies) / len(latencies)
print(f"{model} — Average latency: {avg:.2f}s")
return avg
Iddeċiedi abbażi tar-riżultati
Issa kkrossa-referenza l-kwalità u l-ispiża. Kull kombinazzjoni teħtieġ deċiżjoni differenti, u l-aktar waħda skomoda tibqa’ n-nofs triq: meta ż-żewġ mudelli jkunu ugwali, trid tabbanduna x-xogħol diġà mħallas minflok ma tfittex ġustifikazzjoni wara l-fatt.
| Riżultat | Azzjoni |
|---|---|
| FT jirbaħ fil-kwalità + jispiża inqas | Iddispjega l-mudell imħarreġ b’fine-tuning |
| FT jirbaħ fil-kwalità, jitlif fl-ispiża | Evalwa jekk il-kwalità tiġġustifikax l-ispiża żejda |
| Riżultati simili | Ibqa’ mal-mudell bażi + prompt |
| Il-Bażi tirbaħ | Tejjeb id-data tiegħek u erġa’ pprova |
Punti Ewlenin
- Dejjem qabbel ma’ mudell bażi + prompt ottimizzat, mhux prompt bażiku
- Uża l-ġudizzju tal-LLM biex tawtomatizza l-paragun kwalitattiv
- Kejjel l-ispejjeż u l-latency, mhux biss il-kwalità
- Rata ta’ titjib ta’ 60%+ tiġġustifika l-fine-tuning
- Jekk il-fine-tuning ma jagħtix titjib ċar, ibqa’ mal-inġinerija tal-prompt