Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Összehasonlítás az alapmodellel

11. lecke 16 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. Miért fontos a szisztematikus összehasonlítás
  2. Határozd meg az alapot
  3. Generálj oldalankénti válaszokat
  4. Döntess egy harmadik fél modellel
  5. Hasonlítsd össze a költségeket
  6. Hasonlítsd össze a késleltetést
  7. Dönts az eredmények alapján
  8. Főbb megállapítások

Frissítés: 2026. november 2. — Finomhangolás elérhetősége. Az OpenAI saját kiszolgálású finomhangolási szolgáltatását fokozatosan megszüntetik: 2026. május 7-től azok a szervezetek, amelyek még sosem használták, már nem hozhatnak létre feladatokat; július 2 óta az elmúlt 60 napban használnod kellett egy finomhangolt modellt; és 2027. január 6-tól egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljük nyugdíjazásra nem kerül. Ez a tanfolyam továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén a promptmérnökséget, a RAG-ot és az értékeléseket helyezd előtérbe.

Miért fontos a szisztematikus összehasonlítás

A finomhangolásnak költségei vannak: adatelőkészítési idő, képzési kiadások és karbantartási komplexitás. Bizonyítanod kell, hogy a finomhangolt modelled mérhető javulást nyújt az alapmodellel szemben, erős prompt használata esetén. Ha a különbség csekély, a finomhangolás talán nem éri meg a fáradságot.

A gyakorlat során felmerülő kísértés, hogy a betanított modelledet egy rosszul instruált alapmodellel hasonlítsd össze. Ez hízelgő, de értéktelen demonstrációhoz vezet: olyan ellenfelet győztél le, akit te magad gyengítettél meg. Az egyetlen becsületes összehasonlítás a finomhangolt modelledet az alapmodell lehető legjobb használatával állítja szembe.

Határozd meg az alapot

Az alap az alapmodell a legjobb rendszerpromptoddal kombinálva. Optimalizáld ezt a promptot az összehasonlítás előtt. Konkréten ez azt jelenti, hogy írd le azokat a szabályokat, amelyeket implicit módon példákkal tanítottál meg a finomhangolás során: a szerep, a hangnem, a várható hossz és a beszélgetés lezárásának módja. Az alábbi prompt pontosan ezt teszi egy ügyfélszolgálati asszisztens esetében; vedd észre, hogy a finomhangolt modellnek nincs szüksége ilyen utasításokra, mivel ezek a szabályok most már a súlyainak részét képezik.

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

Generálj oldalankénti válaszokat

A következő lépés, hogy mindkét modellt pontosan ugyanazokra a kérdésekre kérdezd le, és párosítsd a válaszokat. Válassz olyan kérdéseket, amelyek reprezentatívak a valós forgalmadra nézve, nem pedig tankönyvi eseteket: egy szállítási panasz, egy eljárási kérelem, elégedetlenség, visszatérítési kérelem, ténykérdés. Ez az öt kategória számít a éles üzemben, nem a tökéletes megfogalmazás.

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
)

Döntess egy harmadik fél modellel

Néhány száz pár kézi átolvasása gyorsan lehangolóvá válik, és a fáradtság előrehaladtával a megítélés is romlik. Egy harmadik fél modell, amely egyik választ sem generálta, arbitráskodik minden páron négy kritérium alapján, és általános ítéletet hoz. Először semlegesítsd a címkéket: a bíró csak a „Válasz A“ és „Válasz B“ kifejezéseket látja, sosem azt, melyik modell állította elő őket, ellenkező esetben az ítélete ugyanolyan súllyal veszi figyelembe a modell nevét, mint a szöveget. Ezután kezeld azokat az eseteket, amikor a kimenet nem elemezhető; ellenkező esetben egyetlen hibás válasz megakasztja az egész kampányt.

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]

Most aggregáld ezeket az ítéleteket egyetlen számmá. A javulási ráta – azon párok aránya, ahol a finomhangolt modell győz – előre meghatározott küszöbértékekhez viszonyítva értelmezendő: 60% felett a nyereség egyértelmű; 40% és 60% között mérlegeld a nyereséget a többletköltséggel szemben; ez alatt a finomhangolásod nem bizonyított, és a probléma szinte mindig az adatokban rejlik.

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)

Hasonlítsd össze a költségeket

A minőség csak a döntés fele. A finomhangolás gyakran csökkenti a bemeneti tokenek számát, mivel a hosszú prompt feleslegessé válik, de minden token, amelyet egy finomhangolt modellen számláznak, többe kerül. Ez a két hatás ellentétes irányba húz, és csak a számítás dönt. Az alábbi függvény szembeállítja őket egy havi forgalom alapján: egy 500-ról 50 tokenre csökkenő prompt több mint kompenzálja a megduplázódott bemeneti díjat, de ez nem lenne igaz egy már eleve rövid alapprompt esetén.

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
)

Hasonlítsd össze a késleltetést

A prompt több száz tokennel való rövidítése a válaszidőt is befolyásolja, ez pedig egy olyan kritérium, amelyet a felhasználóid jóval hamarabb észrevesznek, mint a hangnem finomságait. Mérd a késleltetést ugyanazokon a kérdéseken, amelyeket a minőségi összehasonlításhoz használtál, csúcsidőn kívül, és ismételd meg a mérést többször: egy egyetlen érték nagyban tükrözi a hálózat állapotát a teszt idején.

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önts az eredmények alapján

Most keresztezd a minőséget és a költségeket. Minden kombináció más döntést igényel, és a legkényelmetlenebb továbbra is a középút: amikor a két modell egyenlő, el kell vetned a már kifizetett munkát, ahelyett, hogy utólag keresnél igazolást rá.

EredményTeendő
FT győz minőségben + költségekbenTelepítsd a finomhangolt modellt
FT győz minőségben, veszít költségekbenÉrtékeld, hogy a minőség indokolja-e a többletköltséget
Hasonló eredményekMaradj az alapmodellnél + promptnál
Alap győzJavítsd az adataidat, és próbáld újra

Főbb megállapítások

  • Mindig alapmodell + optimalizált prompt ellen hasonlíts, ne alapvető prompttal
  • Használj LLM-ítéletet a minőségi összehasonlítás automatizálásához
  • Mérd a költségeket és a késleltetést, ne csak a minőséget
  • A 60%-os vagy annál nagyobb javulási ráta indokolja a finomhangolást
  • Ha a finomhangolás nem hoz egyértelmű javulást, maradj a promptmérnökségnél