Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Primerjava z osnovnim modelom

Lekcija 11 od 16 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Zakaj je sistematična primerjava ključna
  2. Določitev izhodišča
  3. Generiranje vzporednih odgovorov
  4. Naj tretji model opravi oceno
  5. Primerjava stroškov
  6. Primerjava zakasnitve (latence)
  7. Odločitev na podlagi rezultatov
  8. Ključne ugotovitve

Posodobitev 2. november 2026 — Razpoložljivost prilagajanja. Samostojno prilagajanje (fine-tuning) podjetja OpenAI se postopno ukinja: od 7. maja 2026 organizacije, ki ga še niso uporabljale, ne morejo več ustvarjati novih opravil; od 2. julija morate prilagojen model uporabiti vsaj enkrat v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler njihov osnovni model ni umaknjen. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječih modelov; za nove projekte dajte prednost inženiringu pozivov (prompt engineering), arhitekturi RAG in evalvacijam.

Zakaj je sistematična primerjava ključna

Prilagajanje ima svojo ceno: čas za pripravo podatkov, stroške usposabljanja in kompleksnost vzdrževanja. Dokazati moraš, da tvoj prilagojeni model prinaša merljivo izboljšavo v primerjavi z osnovnim modelom, opremljenim z močnim sistemskim pozivom. Če je razlika zanemarljiva, prilagajanje morda ni vredno truda.

Pri tej vaji te lahko premami želja, da bi svoj usposobljeni model primerjal s slabo instruiranim osnovnim modelom. To sicer deluje laskavo, a je brez vrednosti: premagal si nasprotnika, ki si ga sam oslabil. Edina poštena primerjava sooči tvoj prilagojeni model z najboljšo možno uporabo osnovnega modela.

Določitev izhodišča

Izhodišče je osnovni model z tvojim najboljšim sistemskim pozivom. Ta poziv optimiziraj pred primerjavo. Konkretno to pomeni, da zapišeš pravila, ki si jih med prilagajanjem implicitno učil s primeri: vlogo, ton, pričakovano dolžino in način zaključevanja pogovora. Spodnji poziv točno to stori za asistenta za podporo; upoštevaj, da prilagojeni model takih navodil ne potrebuje, saj so ta pravila zdaj del njegovih uteži.

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

Generiranje vzporednih odgovorov

Naslednji korak je poizvedba pri obeh modelih z natanko istimi vprašanji in shranjevanje seznanjenih odgovorov. Izberi vprašanja, ki so reprezentativna za tvoj dejanski promet, in ne učbeniških primerov: pritožba glede dostave, zahtevek za postopek, nezadovoljstvo, zahtevek za vračilo denarja, dejansko vprašanje. Prav teh pet družin primerov naredi razliko v proizvodnem okolju, ne pa popolna formulacija.

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
)

Naj tretji model opravi oceno

Ročno branje stotine parov hitro postane obupno, presoja pa popusti, ko nastopi utrujenost. Tretji model, ki ni ustvaril nobenega od odgovorov, arbitra vsak par glede na štiri merila in izreče globalno sodbo. Najprej nevtraliziraj oznake: sodnik vidi „Odgovor A” in „Odgovor B”, nikoli pa ne ve, kateri model jih je ustvaril; sicer bo njegova sodba tehtala ime modela enako kot besedilo. Nato poskrbi za primere, ko izhod ni mogoče razčleniti; v nasprotnem primeru bo en sam nepravilno oblikovan odgovor ustavil celotno kampanjo.

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]

Zdaj združi te sodbe v eno samo številko. Stopnja izboljšave – delež parov, kjer zmaga prilagojeni model – se meri glede na vnaprej določene pragove: nad 60 % je dobiček očiten; med 40 % in 60 % stehtaj dobiček proti dodatnim stroškom; pod tem tvoje prilagajanje ni dokazalo svoje vrednosti, težava pa skoraj vedno tiči v podatkih.

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)

Primerjava stroškov

Kakovost je le polovica odločitve. Prilagajanje pogosto zmanjša število vhodnih žetonov, saj dolg poziv postane nepotreben, vendar vsak žeton, obračunan za prilagojeni model, stane več. Ta dva učinka vlečeta v nasprotne smeri in le izračun odloči. Spodnja funkcija ju sooči v okviru mesečnega prometa: zmanjšanje poziva s 500 na 50 žetonov več kot kompenzira podvojeno ceno vhoda, vendar to ne bi držalo pri že kratkem osnovnem pozivu.

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
)

Primerjava zakasnitve (latence)

Skrajšanje poziva za več sto žetonov vpliva tudi na čas odziva, kar tvoji uporabniki opazijo veliko prej kot tonske nianse. Latenco izmeri pri istih vprašanjih, ki so bila uporabljena za kvalitativno primerjavo, izven koničnih ur, in meritev večkrat ponovi: ena sama vrednost večinoma odraža stanje omrežja v času testa.

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

Odločitev na podlagi rezultatov

Zdaj zkrižaj kakovost in stroške. Vsaka kombinacija zahteva drugačno odločitev, najbolj neprijetna pa ostaja srednja pot: ko sta oba modela enaka, moraš opustiti že plačano delo, namesto da bi naknadno iskal opravičila.

RezultatUkrep
Prilagojeni model zmaga v kakovosti + stroškihRazporedi prilagojeni model
Prilagojeni model zmaga v kakovosti, izgubi pri stroškihOceni, ali kakovost upravičuje dodatne stroške
Podobni rezultatiOstani pri osnovnem modelu + pozivu
Osnovni model zmagaIzboljšaj svoje podatke in poskusi znova

Ključne ugotovitve

  • Vedno primerjaj z osnovnim modelom + optimiziranim pozivom, ne z osnovnim pozivom
  • Uporabi presojo LLM za avtomatizacijo kvalitativne primerjave
  • Meri stroške in latenco, ne le kakovosti
  • Stopnja izboljšave 60 % ali več upravičuje prilagajanje
  • Če prilagajanje ne prinaša jasne izboljšave, ostani pri inženiringu pozivov