Primerjava z osnovnim modelom
Na tej strani
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.
| Rezultat | Ukrep |
|---|---|
| Prilagojeni model zmaga v kakovosti + stroških | Razporedi prilagojeni model |
| Prilagojeni model zmaga v kakovosti, izgubi pri stroških | Oceni, ali kakovost upravičuje dodatne stroške |
| Podobni rezultati | Ostani pri osnovnem modelu + pozivu |
| Osnovni model zmaga | Izboljš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