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

Qabbel mal-Mudell Bażi

Lezzjoni 11 / 16 Aġġornat 2 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Għaliex il-paragun sistematiku huwa importanti
  2. Iddefinixxi l-linja bażi
  3. Iġġenera tweġibiet ġenb ma’ ġenb
  4. Ħalli mudell ta’ parti terza jħaqqem
  5. Qabbel l-ispejjeż
  6. Qabbel il-latency
  7. Iddeċiedi abbażi tar-riżultati
  8. Punti Ewlenin

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żultatAzzjoni
FT jirbaħ fil-kwalità + jispiża inqasIddispjega l-mudell imħarreġ b’fine-tuning
FT jirbaħ fil-kwalità, jitlif fl-ispiżaEvalwa jekk il-kwalità tiġġustifikax l-ispiża żejda
Riżultati similiIbqa’ 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