Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Porovnání se základním modelem

Lekce 11 z 16 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Proč je systematické porovnání klíčové
  2. Definice výchozího stavu (Baseline)
  3. Generování odpovědí vedle sebe
  4. Nech posoudit třetí model
  5. Porovnání nákladů
  6. Porovnání latence
  7. Rozhodnutí na základě výsledků
  8. Klíčové poznatky

Aktualizace 2. listopadu 2026 — Dostupnost doladění. Služba vlastního doladění (fine-tuning) od OpenAI je postupně ukončována: od 7. května 2026 již organizace, které ji nikdy nepoužily, nemohou vytvářet nové úlohy; od 2. července musíte mít doladěný model použitý během posledních 60 dnů; a počínaje 6. lednem 2027 žádný zákazník nebude moci spustit nové úlohy. Již natrénované modely zůstávají použitelné až do vyřazení jejich základního modelu. Tento kurz je stále užitečný pro pochopení a využití existujícího modelu; u nových projektů upřednostňujte inženýrství promptů, RAG a evaluace.

Proč je systematické porovnání klíčové

Doladění má svou cenu: čas na přípravu dat, náklady na trénink a složitost údržby. Musíš prokázat, že tvůj doladěný model přináší měřitelné zlepšení oproti základnímu modelu s dobře navrženým promptem. Pokud je rozdíl marginální, doladění nemusí stát za tu námahu.

Pokušením v tomto cvičení je porovnat tvůj natrénovaný model se základním modelem, kterému byly zadány špatné instrukce. To vede k lichotivému, ale bezcennému předvedení: porazil jsi soupeře, kterého jsi sám oslabil. Jediné poctivé porovnání staví tvůj doladěný model proti nejlepšímu možnému využití základního modelu.

Definice výchozího stavu (Baseline)

Výchozím stavem je základní model s tvým nejlepším systémovým promptem. Tento prompt optimalizuj před samotným porovnáním. Konkrétně to znamená sepsat pravidla, která jsi implicitně učil prostřednictvím příkladů během doladění: roli, tón, očekávanou délku a způsob ukončení konverzace. Níže uvedený prompt dělá přesně toto pro asistenta podpory; všimni si, že doladěný model takové instrukce nepotřebuje, protože tato pravidla jsou nyní součástí jeho vah.

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

Generování odpovědí vedle sebe

Dalším krokem je dotazování obou modelů na úplně stejné otázky a uchování spárovaných odpovědí. Vyber otázky reprezentativní pro tvůj skutečný provoz, nikoliv učebnicové příklady: stížnost na doručení, žádost o postup, nespokojenost, žádost o vrácení peněz, faktická otázka. Právě těchto pět kategorií dělá v produkci rozdíl, nikoliv dokonalé formulace.

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
)

Nech posoudit třetí model

Ruční čtení stovek párů odpovědí rychle demotivuje a s únavou klesá kvalita úsudku. Třetí model, který nevygeneroval ani jednu z odpovědí, rozhodne o každém páru na základě čtyř kritérií a vynese celkový verdikt. Nejprve neutralizuj štítky: rozhodčí vidí „Odpověď A“ a „Odpověď B“, nikdy neví, který model je vygeneroval, jinak by jeho verdikt vážil název modelu stejně jako text odpovědi. Dále ošetři případy, kdy výstup není parsitelný; jinak jediný chybně formátovaný výstup zastaví celou 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]

Nyní agreguj tyto verdikty do jediného čísla. Míra zlepšení – podíl párů, kde vyhrál doladěný model – se posuzuje proti předem definovaným prahům: nad 60 % je zisk jasný; mezi 40 % a 60 % zvaž zisk proti dodatečným nákladům; pod touto hranicí se tvé doladění neprokázalo a problém téměř vždy leží v datech.

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)

Porovnání nákladů

Kvalita je jen polovinou rozhodování. Doladění často snižuje počet vstupních tokenů, protože dlouhý prompt není potřebný, ale každý token fakturovaný u doladěného modelu stojí více. Tyto dva efekty táhnou opačným směrem a rozhoduje až výpočet. Níže uvedená funkce je postaví proti sobě pro měsíční provoz: snížení promptu z 500 na 50 tokenů více než vynahradí zdvojnásobenou cenu za vstup, ale to by neplatilo pro již krátký základní prompt.

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
)

Porovnání latence

Zkrácení promptu o několik stovek tokenů ovlivňuje také dobu odezvy, což je kritérium, kterého si uživatelé všimnou dříve než jemnosti tónu. Změř latenci na stejných otázkách použitých pro kvalitativní porovnání, mimo špičku, a měření několikrát opakuj: jediná hodnota většinou odráží pouze stav sítě v době 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

Rozhodnutí na základě výsledků

Nyní zkombinuj kvalitu a náklady. Každá kombinace vyžaduje jiné rozhodnutí a to nejnepříjemnější zůstává střední cesta: když jsou si oba modely rovny, musíš opustit již zaplacenou práci, než abys hledal dodatečné ospravedlnění.

VýsledekAkce
FT vítězí v kvalitě + nákladechNasadit doladěný model
FT vítězí v kvalitě, prohrává v nákladechPosoudit, zda kvalita ospravedlňuje vyšší náklady
Podobné výsledkyZůstat u základního modelu + promptu
Vítězí základní modelZlepšit data a zkusit to znovu

Klíčové poznatky

  • Vždy porovnávej se základním modelem + optimalizovaným promptem, nikoliv se základním promptem
  • Použij posouzení LLM pro automatizaci kvalitativního porovnání
  • Měř náklady a latenci, nejen kvalitu
  • Míra zlepšení 60 % a více ospravedlňuje doladění
  • Pokud doladění nepřináší jasné zlepšení, drž se inženýrství promptů