Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Usporedba s osnovnim modelom

Lekcija 11 od 16 Ažurirano 2. studenoga 2026. Napredno
Na ovoj stranici
  1. Zašto je sustavna usporedba važna
  2. Definiranje polazne točke
  3. Generiranje odgovora jedan uz drugi
  4. Neka treći model presudi
  5. Usporedba troškova
  6. Usporedba latencije
  7. Odluči na temelju rezultata
  8. Ključne točke

Ažuriranje 2. studenoga 2026. — Dostupnost fino podešavanja. OpenAI postupno ukida samostalno fino podešavanje: od 7. svibnja 2026. organizacije koje ga nikada nisu koristile više ne mogu pokretati zadatke; od 2. srpnja moraš koristiti fino podešeni model unutar posljednjih 60 dana; a počevši od 6. siječnja 2027., nijedan korisnik više neće moći pokrenuti nove zadatke. Već obučeni modeli ostaju upotrebljivi dok se njihov osnovni model ne povuče. Ovaj tečaj i dalje je koristan za razumijevanje i iskorištavanje postojećeg modela; za nove projekte daj prednost inženjerstvu prompta, RAG-u i evaluacijama.

Zašto je sustavna usporedba važna

Fino podešavanje ima svoju cijenu: vrijeme pripreme podataka, troškove obuke i složenost održavanja. Moraš dokazati da tvoj fino podešeni model donosi mjerljivo poboljšanje u odnosu na osnovni model uz snažan prompt. Ako je razlika marginalna, fino podešavanje možda nije vrijedno truda.

Iskušenje u ovoj vježbi jest usporediti tvoj obučeni model s loše instruiranim osnovnim modelom. To stvara laskavu, ali bezvrijednu demonstraciju: pobijedio si protivnika kojeg si sam oslabio. Jedina poštena usporedba suprotstavlja tvoj fino podešeni modelu najboljoj mogućoj uporabi osnovnog modela.

Definiranje polazne točke

Polazna točka je osnovni model s tvojim najboljim sistemskim promptom. Optimiziraj taj prompt prije usporedbe. Konkretno, to znači zapisati pravila koja si implicitno podučio primjerima tijekom fino podešavanja: ulogu, ton, očekivanu duljinu i način završetka razmjene. Donji prompt čini upravo to za asistenta za podršku; imaj na umu da fino podešeni model ne treba takve upute jer su ta pravila sada dio njegovih težina.

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 odgovora jedan uz drugi

Sljedeći korak je upit oba modela s točno istim pitanjima i zadržavanje uparenih odgovora. Odaberi pitanja koja su reprezentativna za tvoj stvarni promet, a ne udžbeničke slučajeve: pritužba na dostavu, zahtjev za postupak, nezadovoljstvo, zahtjev za povrat novca, činjenično pitanje. Ovih pet kategorija čini razliku u proizvodnji, a ne savršeno formuliranje.

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
)

Neka treći model presudi

Ručno čitanje stotinu parova brzo postaje obeshrabrujuće, a prosudba popušta kako umor raste. Treći model, koji nije proizveo nijedan odgovor, arbitrirat će svaki par prema četiri kriterija i donijeti globalnu presudu. Prvo, neutraliziraj oznake: sudac vidi „Odgovor A“ i „Odgovor B“, nikada koji ih je model proizveo, inače će njegova presuda vrednovati ime modela jednako kao i tekst. Zatim, riješi slučajeve gdje izlaz nije moguće parsirati; inače će jedan neispravan odgovor zaustaviti cijelu kampanju.

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]

Sada agregiraj ove presude u jednu brojku. Stopa poboljšanja – udio parova u kojima pobjeđuje fino podešeni model – čita se prema unaprijed definiranim pragovima: iznad 60%, dobitak je jasan; između 40% i 60%, izvagni dobitak naspram dodatnog troška; ispod toga, tvoje fino podešavanje se nije dokazalo, a problem gotovo uvijek leži u podacima.

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)

Usporedba troškova

Kvaliteta je samo pola odluke. Fino podešavanje često smanjuje ulazne tokene jer dugi prompt postaje nepotreban, ali se svaki token naplaćen na fino podešenom modelu više košta. Ova dva efekta vuku u suprotnim smjerovima, a samo izračun donosi odluku. Donja funkcija suprotstavlja ih jedno drugome tijekom mjesec dana prometa: pad prompta sa 500 na 50 tokena više nego nadoknađuje udvostručenu cijenu ulaza, no to ne bi vrijedilo s već kratkim osnovnim promptom.

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
)

Usporedba latencije

Skraćivanje prompta za nekoliko stotina tokena također utječe na vrijeme odgovora, kriterij koji tvoji korisnici primijete znatno prije tonske profinjenosti. Izmjeri latenciju na istim pitanjima korištenima za kvalitativnu usporedbu, izvan špica, i ponovi mjerenje nekoliko puta: jedna vrijednost uglavnom odražava stanje mreže u vrijeme 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

Odluči na temelju rezultata

Sada ukrsti kvalitetu i troškove. Svaka kombinacija zahtijeva drugačiju odluku, a najneugodnija ostaje sredina: kada su dva modela jednaka, moraš napustiti već plaćeni rad umjesto da naknadno tražiš opravdanje.

RezultatAkcija
FT pobjeđuje u kvaliteti + troškovimaImplementiraj fino podešeni model
FT pobjeđuje u kvaliteti, gubi u troškovimaProcijeni opravdava li kvaliteta dodatni trošak
Slični rezultatiOstani uz osnovni model + prompt
Osnovni model pobjeđujePoboljšaj svoje podatke i pokušaj ponovno

Ključne točke

  • Uvijek uspoređuj s osnovnim modelom + optimiziranim promptom, a ne s osnovnim promptom
  • Koristi procjenu LLM-a za automatizaciju kvalitativne usporedbe
  • Mjeri troškove i latenciju, a ne samo kvalitetu
  • Stopa poboljšanja od 60%+ opravdava fino podešavanje
  • Ako fino podešavanje ne donosi jasno poboljšanje, ostani uz inženjerstvo prompta