Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Déan comparáid leis an mBunmhúnla

Ceacht 11 as 16 Nuashonraithe 2 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. Cén fáth a bhfuil tábhacht le comparáid chórasach
  2. Sainigh an bonnlíne
  3. Giniúint freagraí taobh le taobh
  4. Iarr ar mhúnla tríú páirtí breith a thabhairt
  5. Déan comparáid idir costais
  6. Déan comparáid idir moill
  7. Déan cinneadh bunaithe ar thorthaí
  8. Príomhphointí

Nuashonrú 2 Samhain, 2026 — Fáil ar fhíneáil. Tá an tseirbhís fhéinseirbhíse fíneála ó OpenAI á céimniú amach: ón 7 Bealtaine, 2026, ní féidir le heagraíochtaí nach bhfuil tar éis í a úsáid riamh post a chruthú a thuilleadh; ón 2 Iúil, caithfidh tú múnla fíneáilte a bheith úsáidte agat laistigh de na 60 lá seo caite; agus ag tosú 6 Eanáir, 2027, ní bheidh aon chustaiméir in ann poist nua a sheoladh. Fanann múnlaí atá traenáilte cheana inúsáidte go dtí go gcuirtear deireadh lena mbunmhúnla. Fanann an cúrsa seo úsáideach chun múnla atá ann cheana a thuiscint agus a shaothrú; do thionscadail nua, tabhair tosaíocht d’innealtóireacht leideanna, RAG, agus meastóireachtaí.

Cén fáth a bhfuil tábhacht le comparáid chórasach

Tá costas ag baint le fíneáil: am ullmhúcháin sonraí, costais oiliúna, agus castacht cothabhála. Caithfidh tú a chruthú go soláthraíonn do mhúnla fíneáilte feabhas intomhaiste ar an mbunmhúnla le leid láidir. Má tá an difríocht imeallach, b’fhéidir nach fiú an iarracht a bhaineann le fíneáil.

Is é an tspreagadh sa chleachtadh seo ná do mhúnla traenáilte a chur i gcomparáid le bunmhúnla atá treoraithe go dona. Cruthaíonn sé sin léiriú flaitiúil ach gan fiúntas: tá tú tar éis buachan ar chéile a laghdaigh tú féin. Ní dhéanann ach comparáid ionraic cur i gcoinne do mhúnla fíneáilte in aghaidh an úsáid is fearr is féidir a bhaint as an mbunmhúnla.

Sainigh an bonnlíne

Is é an bonnlíne ná an bunmhúnla le do leid córais is fearr. Déan an leid seo a optamú sula ndéanann tú comparáid. Go praiticiúil, ciallaíonn sé seo na rialacha a mhúin tú go hintreach trí shampla le linn na fíneála a scríobh síos: an ról, an tón, an fad a bhfuiltear ag súil leis, agus conas malartú a chríochnú. Déanann an leid thíos go díreach é sin do chúntóir tacaíochta; tabhair faoi deara nach bhfuil gá le treoracha den sórt sin ag an múnla fíneáilte, ós rud é go bhfuil na rialacha seo ina gcuid meáchan anois.

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

Giniúint freagraí taobh le taobh

Is é an chéad chéim eile ná ceist a chur ar an dá mhúnla ar na ceisteanna céanna go díreach agus na freagraí péireáilte a choinneáil. Roghnaigh ceisteanna atá ionadaíoch do do thrácht fíor seachas cásanna téacsleabhair: gearán faoi sheachadadh, iarratas ar nós imeachta, míshástacht, iarratas ar aisíocaíocht, ceist fhíorasach. Is iad na cúig theaghlach seo a dhéanann an difríocht sa táirgeadh, ní an fhráseáil fhoirfe.

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
)

Iarr ar mhúnla tríú páirtí breith a thabhairt

Éiríonn sé míchompordach go tapa céad péire a léamh de láimh, agus meathlaíonn an breithiúnas de réir mar a thagann tuirse ort. Déanann múnla tríú páirtí, nach ndearna ceachtar den fhreagra, idirghabháil ar gach péire bunaithe ar cheithre chritéar agus tugann sé breithiúnas domhanda. Ar dtús, déan na lipéid a neodrú: feiceann an breitheamh “Freagra A” agus “Freagra B”, riamh cé acu múnla a tháirg iad, murach sin beidh tionchar ag ainm an mhúnla ar a bhreithiúnas chomh mór leis an téacs. Ina dhiaidh sin, déileáil le cásanna nach féidir an t-aschur a pharsáil; murach sin, stopann freagra amháin atá míchruthaithe an feachtas ar fad.

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]

Anois comhiomlánaigh na breithiúnais seo ina figiúr amháin. Léitear an ráta feabhsaithe—an sciar de phéirí ina mbuaíonn an múnla fíneáilte—in aghaidh tairseacha réamhshainithe: os cionn 60%, tá an gnóthachan soiléir; idir 40% agus 60%, meáigh an gnóthachan i gcoinne an chostais bhreise; faoi bhun sin, níor chruthaigh do fhíneáil é féin, agus is minic gurb iad na sonraí atá faoi deara an fhadhb.

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)

Déan comparáid idir costais

Ní leath an chinneadh ach an cháilíocht. Go minic laghdaíonn fíneáil na tokenanna ionchuir toisc nach gá an leid fada a thuilleadh, ach costálann gach token a bhilleáiltear ar mhúnla fíneáilte níos mó. Tarraingíonn an dá éifeacht seo i dtreoracha contrártha, agus ní chinneann ach an ríomh. Cuirtear i gcoinne a chéile iad sa fheidhm thíos thar mhí tráchtta: laghdaíonn leid ó 500 go 50 token níos mó ná ráta dúbailte ionchuir a chúiteamh, ach ní bheadh sé sin fíor le leid bunúsach atá gairid cheana féin.

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
)

Déan comparáid idir moill

Bíonn tionchar ag giorrú leid de roinnt céad token ar am freagartha freisin, critéar a thugann do chuid úsáideoirí faoi deara i bhfad roimh mhínithe tóna. Tomhais an mhoill ar na ceisteanna céanna a úsáideadh don chomparáid cháilíochtúil, lasmuigh d’uairbhuaic, agus déan an tomhas arís roinnt uaireanta: is minic a léiríonn luach amháin staid an líonra ag am an tástála den chuid is mó.

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

Déan cinneadh bunaithe ar thorthaí

Anois tras-tagairt cáilíocht agus costas. Éilíonn gach comhcheangal cinneadh difriúil, agus is é an meánchríoch an ceann is míchompordaí fós: nuair atá an dá mhúnla cothrom, caithfidh tú obair a íocadh cheana a thréigean seachas údar a lorg tar éis na fíricí.

ToradhGníomh
Buaíonn FT ar cháilíocht + costaisDéan an múnla fíneáilte a imlonnú
Buaíonn FT ar cháilíocht, cailleann ar chostaisMeas an bhfuil an cháilíocht ag údarú an chostais bhreise
Torthaí cosúlaFan leis an mbunmhúnla + leid
Buaíonn an BunmhúnlaFeabhsaigh do chuid sonraí agus bain triail eile as

Príomhphointí

  • Déan comparáid i gcónaí le bunmhúnla + leid optamaithe, ní le leid bunúsach
  • Úsáid breithiúnas LLM chun comparáid cháilíochtúil a uathoibriú
  • Tomhais costais agus moill, ní hamháin cáilíocht
  • Údharaíonn ráta feabhsaithe 60%+ fíneáil
  • Mura soláthraíonn fíneáil feabhas soiléir, fan le hinnealtóireacht leideanna