Võrdle baasmudeliga
Sellel lehel
Uuendus 2. november 2026 — Häälestamise kättesaadavus. OpenAI iseteeninduslik häälestamine kaotatakse järk-järgult: alates 7. maist 2026 ei saa organisatsioonid, kes seda varem kasutanud pole, enam uusi ülesandeid luua; alates 2. juulist peab olema viimase 60 päeva jooksul kasutatud häälestatud mudelit; ja alates 6. jaanuarist 2027 ei saa ükski klient uusi ülesandeid käivitada. Juba treenitud mudeleid saab kasutada seni, kuni nende baasmudel on kasutuselt kõrvaldatud. See kursus on endiselt kasulik olemasoleva mudeli mõistmiseks ja ärakasutamiseks; uute projektide puhul seada esikohale viibade inseneeria (prompt engineering), RAG ja hindamine.
Miks on süstemaatiline võrdlus oluline
Häälestamisega kaasnevad kulud: andmete ettevalmistamise aeg, treenimiskulud ja hoolduse keerukus. Sa pead tõestama, et sinu häälestatud mudel pakub mõõdetavat paremust võrreldes baasmudeliga, mida on toetatud tugeva viibaga (prompt). Kui erinevus on marginaalne, ei pruugi häälestamine vaeva väärt olla.
Selles harjutuses tekib kiusatus võrrelda oma treenitud mudelit halvasti juhendatud baasmudeliga. See annab küll meelitava, kuid väärtusetu tulemuse: oled võitnud vastast, keda ise nõrgendasid. Ainult aus võrdlus seab sinu häälestatud mudeli vastamisi baasmudeli parima võimaliku kasutamisviisiga.
Määra baasjoon
Baasjooneks on baasmudel koos sinu parima süsteemiviibaga. Optimeeri see viip enne võrdlemist. Konkreetsemalt tähendab see, et kirjutad üles reeglid, mida häälestamise käigus näidete abil implitsiitselt õpetasid: roll, toon, oodatav pikkus ja viis, kuidas vestlus lõpetada. Allpool olev viip teeb seda täpselt tugiteenuse assistendi jaoks; pane tähele, et häälestatud mudel selliseid juhiseid ei vaja, kuna need reeglid on nüüd osa tema kaaludest.
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
Genereeri kõrvuti vastused
Järgmine samm on pärida mõlemalt mudelilt täpselt samadele küsimustele ja säilitada paarikaupa vastused. Vali küsimused, mis esindavad sinu tegelikku liiklust, mitte õpikunäiteid: kaebus kohaletoimetamise kohta, protseduuri päring, rahulolematus, tagasimakse taotlus, faktiline küsimus. Need viis kategooriat teevad tootmises vahet, mitte täiuslik sõnastus.
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
)
Lase kolmandal mudelil hinnata
Sada paari käsitsi lugemine muutub kiiresti heidutavaks ja hinnangud moonduvad väsimuse tõttu. Kolmas mudel, mis kumbagi vastust ei loonud, arbitreerib iga paari nelja kriteeriumi alusel ja teeb üldise otsuse. Esiteks neutraliseeri sildid: hindaja näeb „Vastus A“ ja „Vastus B“, mitte kunagi seda, kumb mudel need lõi, vastasel juhul kaalub tema otsus mudeli nime sama palju kui teksti. Seejärel lahenda juhtumid, kus väljundit ei saa parsida; vastasel juhul peatab üksainus vigane vastus kogu kampaania.
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]
Nüüd koonda need otsused üheks näitajaks. Paremusmäär – osakaal paaridest, kus häälestatud mudel võidab – asetatakse eelnevalt määratletud lävenditega võrdlusesse: üle 60% on kasv selge; 40% ja 60% vahel kaalu kasu lisakulude vastu; sellest allpool pole sinu häälestus ennast tõestanud ja probleem peitub peaaegu alati andmetes.
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)
Võrdle kulusid
Kvaliteet on vaid pool otsust. Häälestamine vähendab sageli sisendtokeneid, kuna pikk viip muutub tarbetuks, kuid iga häälestatud mudelil arvestatud token maksab rohkem. Need kaks efekti tõmbavad vastassuundades ja ainult arvutus otsustab. Allpool olev funktsioon seab need üksteise vastu kuu liikluse lõikes: viiba lühenemine 500-lt 50 tokenile kompenseerib enam kui kahekordistunud sisendhinda, kuid see ei kehti juba lühikese baasviiba puhul.
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
)
Võrdle latentsust
Viiba lühendamine mitme saja tokeni võrra mõjutab ka vastamisaega, mida kasutajad märkavad kaua enne tooni peenust. Mõõda latentsust samadel küsimustel, mida kasutasid kvalitatiivses võrdluses, väljaspool tipptunde, ja korda mõõtmist mitu korda: üksik väärtus peegeldab enamasti võrgu olekut testi hetkel.
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
Tee otsus tulemuste põhjal
Nüüd vii omavahel kokku kvaliteet ja kulud. Iga kombinatsioon nõuab erinevat otsust ja kõige ebamugavam on kesktee: kui kaks mudelit on võrdsed, pead loobuma juba tasutud tööst, selle asemel et otsida tagantjärele õigustust.
| Tulemus | Tegevus |
|---|---|
| Häälestatud mudel võidab kvaliteedis + kuludes | Võta kasutusele häälestatud mudel |
| Häälestatud mudel võidab kvaliteedis, kaotab kuludes | Hinda, kas kvaliteet õigustab lisakulu |
| Sarnased tulemused | Jää baasmudeli + viiba juurde |
| Baasmudel võidab | Paranda oma andmeid ja proovi uuesti |
Peamised punktid
- Võrdle alati baasmudeli + optimeeritud viibaga, mitte lihtsa viibaga
- Kasuta LLM-hindamist kvalitatiivse võrdluse automatiseerimiseks
- Mõõda kulusid ja latentsust, mitte ainult kvaliteeti
- Paremusmäär üle 60% õigustab häälestamist
- Kui häälestus ei paku selget paremust, jää viibade inseneeria juurde