Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Porovnanie so základným modelom

Lekcia 11 z 16 Aktualizované 2. novembra 2026 Pokročilý
Na tejto strane
  1. Prečo je systematické porovnanie dôležité
  2. Definovanie východiska
  3. Generovanie odpovedí vedľa seba
  4. Nechaj posúdiť tretí model
  5. Porovnanie nákladov
  6. Porovnanie latencie
  7. Rozhodnutie na základe výsledkov
  8. Kľúčové poznatky

Aktualizácia 2. novembra 2026 — Dostupnosť jemného doladenia. Služba samoobslužného jemného doladenia od OpenAI sa postupne ukončuje: od 7. mája 2026 organizácie, ktoré ju nikdy nepoužili, už nemôžu vytvárať nové úlohy; od 2. júla musíte mať použitý jemne doladený model za posledných 60 dní; a počnúc 6. januárom 2027 žiadny zákazník nebude môcť spustiť nové úlohy. Už natrénované modely zostávajú použiteľné až do vyradenia ich základného modelu. Tento kurz zostáva užitočný na pochopenie a využitie existujúceho modelu; pre nové projekty uprednostnite inžinierstvo promptov, RAG a evaluácie.

Prečo je systematické porovnanie dôležité

Jemné doladenie má svoju cenu: čas na prípravu dát, náklady na trénovanie a zložitosť údržby. Musíš preukázať, že tvoj jemne doladený model prináša merateľné zlepšenie oproti základnému modelu s kvalitným promptom. Ak je rozdiel marginálny, jemné doladenie sa nemusí oplatiť.

Pokúšať sa v tomto cvičení porovnať tvoj natrénovaný model so základným modelom, ktorému dáš zlý inštruktážny prompt, je lákavé. Vytvorí to lichotivé, no bezcenné predvedenie: porazil si súpera, ktorého si sám oslabil. Jediné čestné porovnanie postaví tvoj jemne doladený model proti najlepšiemu možnému využitiu základného modelu.

Definovanie východiska

Východiskom je základný model s tvojím najlepším systémovým promptom. Tento prompt optimalizuj ešte pred porovnaním. Konkrétne to znamená zapísať si pravidlá, ktoré si implicitne učil príkladmi počas jemného doladenia: rolu, tón, očakávanú dĺžku a spôsob ukončenia výmeny. Nižšie uvedený prompt robí presne toto pre asistenta podpory; všimni si, že jemne doladený model takéto inštrukcie nepotrebuje, keďže tieto pravidlá sú teraz súčasťou jeho váh.

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

Generovanie odpovedí vedľa seba

Ďalším krokom je opýtanie sa oboch modelov na úplne rovnaké otázky a uchovanie párových odpovedí. Vyber otázky, ktoré reprezentujú tvoju reálnu prevádzku, nie učebnicové prípady: sťažnosť na doručenie, žiadosť o postup, nespokojnosť, žiadosť o vrátenie peňazí, faktografická otázka. Týchto päť kategórií robí rozdiel v produkcii, nie dokonale formulované vety.

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
)

Nechaj posúdiť tretí model

Ručné čítanie stoviek párov sa rýchlo stane odrádzajúcim a úsudok sa s únavou zhoršuje. Tretí model, ktorý nevygeneroval ani jednu z odpovedí, rozhodne o každom páre na základe štyroch kritérií a vyniesie celkový verdikt. Najprv neutralizuj štítky: rozhodca vidí „Odpoveď A“ a „Odpoveď B“, nikdy nie to, ktorý model ich vyprodukoval, inak bude jeho verdikt vážiť názov modelu rovnako ako text. Ďalej ošetri prípady, keď výstup nie je spracovateľný; inak jediná chybná odpoveď zastaví celú kampaň.

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]

Teraz agreguj tieto verdikty do jedného čísla. Miera zlepšenia – podiel párov, kde vyhrá jemne doladený model – sa porovnáva s preddefinovanými prahmi: nad 60 % je zisk jasný; medzi 40 % a 60 % zváž zisk oproti dodatočným nákladom; pod touto hranicou sa tvoje jemné doladenie nepreukázalo a problém takmer vždy leží v dátach.

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)

Porovnanie nákladov

Kvalita je len polovicou rozhodnutia. Jemné doladenie často znižuje počet vstupných tokenov, keďže dlhý prompt sa stáva zbytočným, no každý token fakturovaný na jemne doladenom modeli stojí viac. Tieto dva efekty ťahajú opačným smerom a rozhodnutie prináša až výpočet. Funkcia nižšie ich postaví proti sebe v rámci mesačnej prevádzky: pokles promptu z 500 na 50 tokenov viac ako vykompenzuje zdvojnásobenú cenu vstupu, no to by neplatilo pri už krátkom základnom prompte.

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
)

Porovnanie latencie

Skrátenie promptu o niekoľsto tokenov ovplyvňuje aj čas odozvy, čo je kritérium, ktoré tvoji používatelia zaznamenajú skôr než tónovú jemnosť. Latenciu meraj na tých istých otázkach použitých pri kvalitatívnom porovnaní, mimo špičky, a meranie niekoľkokrát zopakuj: jedna hodnota väčšinou odráža iba stav siete v čase testu.

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

Rozhodnutie na základe výsledkov

Teraz skríž kvalitu a náklady. Každá kombinácia si vyžaduje iné rozhodnutie a najnepohodlnejšia zostáva stredná cesta: keď sú si oba modely rovné, musíš opustiť už zaplatenú prácu, namiesto toho, aby si hľadal dodatočné ospravedlnenie.

VýsledokAkcia
FT vyhráva v kvalite + nákladochNasadiť jemne doladený model
FT vyhráva v kvalite, prehráva v nákladochPosúdiť, či kvalita ospravedlňuje vyššie náklady
Podobné výsledkyZostať pri základnom modeli + prompte
Vyhráva základný modelZlepšiť dáta a skúsiť to znova

Kľúčové poznatky

  • Vždy porovnávaj so základným modelom + optimalizovaným promptom, nie so základným promptom
  • Na automatizáciu kvalitatívneho porovnania použi úsudok LLM
  • Meraj náklady a latenciu, nielen kvalitu
  • Miera zlepšenia 60 % a viac ospravedlňuje jemné doladenie
  • Ak jemné doladenie neprináša jasné zlepšenie, drž sa inžinierstva promptov