Palyginimas su baziniu modeliu
Šiame puslapyje
Atnaujinimas 2026 m. lapkričio 2 d. — Derinimo prieinamumas. „OpenAI“ savitarnos derinimo paslauga yra nutraukiama: nuo 2026 m. gegužės 7 d. organizacijos, kurios ja niekada nesinaudojo, nebegali kurti naujų užduočių; nuo liepos 2 d. būtina būti naudojus derintą modelį per pastaruosius 60 dienų; o nuo 2027 m. sausio 6 d. joks klientas nebegalės paleisti naujų derinimo užduočių. Jau apmokyti modeliai išlieka naudojami tol, kol jų bazinis modelis nėra pašalinamas. Šis kursas išlieka naudingas norint suprasti ir išnaudoti esamą modelį; naujiems projektams teikite pirmenybę promptų inžinerijai, RAG ir vertinimams.
Kodėl sisteminis palyginimas yra svarbus
Derinimas turi kainą: duomenų paruošimo laiką, mokymo išlaidas ir priežiūros sudėtingumą. Turi įrodyti, kad tavo derintas modelis suteikia išmatuojamą pagerėjimą, lyginant su baziniu modeliu, naudojančiu stiprų promptą. Jei skirtumas yra nežymus, derinimas gali būti nevertas pastangų.
Šio pratimo pagunda yra palyginti savo apmokytą modelį su prastai instruktuotu baziniu modeliu. Tai sukuria gražią, bet bevertę demonstraciją: nugalėjai priešininką, kurį pats susilpninai. Vienintelis sąžiningas palyginimas priešpriešina tavo derintą modelį geriausiam įmanomam bazinio modelio naudojimui.
Apibrėžk pagrindinę liniją (Baseline)
Pagrindinė linija yra bazinis modelis su tavo geriausiu sistemos promptu. Prieš lygindamas, optimizuok šį promptą. Konkrečiai tai reiškia užrašyti taisykles, kurias numanomai išmokei pavyzdžiais derinimo metu: vaidmenį, toną, tikėtiną ilgį ir tai, kaip užbaigti dialogą. Toliau pateiktas promptas tai tiksliai ir daro klientų aptarnavimo asistentui; atkreipk dėmesį, kad derintam modeliui tokių instrukcijų nereikia, nes šios taisyklės dabar yra jo svorių dalis.
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
Generuok atsakymus greta
Kitas žingsnis – užklausti abu modelius tais pačiais klausimais ir išsaugoti poruotus atsakymus. Pasirink klausimus, kurie atspindi tavo realų srautą, o ne vadovėlinius atvejus: skundas dėl pristatymo, procedūros užklausa, nepasitenkinimas, grąžinimo prašymas, faktinis klausimas. Būtent šios penkios kategorijos lemia skirtumą gamyboje, o ne tobulas formuluotes.
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
)
Paverk vertinimą trečiajai šaliai (modeliui)
Šimto porų skaitymas rankiniu būdu greitai tampa varginantis, o vertinimo kokybė krenta dėl nuovargio. Trečiosios šalies modelis, kuris nesukūrė nė vieno atsakymo, arbitruoja kiekvieną porą pagal keturis kriterijus ir pateikia bendrą verdiktą. Pirma, neutralizuok etiketes: vertintojas mato „Atsakymas A“ ir „Atsakymas B“, bet niekada nežino, kuris modelis juos sugeneravo, kitaip jo verdiktas svors modelio pavadinimą tiek pat, kiek ir tekstą. Antra, tvarkyk atvejus, kai išvestis nėra analizuojama; kitaip vienas neteisingai suformuotas atsakymas sustabdys visą kampaniją.
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]
Dabar suagreguok šiuos verdiktus į vieną skaičių. Pagerėjimo rodiklis – porų dalis, kurioje laimi derintas modelis – yra vertinamas pagal iš anksto nustatytas ribas: viršijus 60 %, nauda yra akivaizdi; tarp 40 % ir 60 %, pasverk naudą prieš papildomas išlaidas; žemiau šios ribos tavo derinimas neįrodė savo vertės, ir problema beveik visada slypi duomenyse.
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)
Palygink išlaidas
Kokybė yra tik pusė sprendimo. Derinimas dažnai sumažina įvesties tokenų skaičių, nes ilgas promptas tampa nereikalingas, tačiau kiekvienas tokenas, apmokestintas derintame modelyje, kainuoja daugiau. Šie du efektai veikia priešingomis kryptimis, ir tik skaičiavimas lemia rezultatą. Toliau pateikta funkcija juos priešpriešina vieno mėnesio srauto kontekste: prompto sutrumpinimas nuo 500 iki 50 tokenų daugiau nei kompensuoja dvigubai didesnę įvesties kainą, tačiau tai negaliotų, jei bazinis promptas jau būtų trumpas.
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
)
Palygink delsą (Latency)
Prompto sutrumpinimas šimtais tokenų taip pat veikia atsako laiką – kriterijų, kurį tavo vartotojai pastebi gerokai anksčiau nei tonų niuansus. Išmatuok delsą tiems patiems klausimams, naudotiems kokybiniam palyginimui, ne piko valandomis, ir kartok matavimą kelis kartus: viena reikšmė dažniausiai atspindi tik tinklo būklę testavimo metu.
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
Spręsk pagal rezultatus
Dabar sugretink kokybę ir kainą. Kiekvienas derinys reikalauja skirtingo sprendimo, o nepatogiausia lieka vidurio pozicija: kai abu modeliai yra lygiaverčiai, turi atsisakyti jau apmokėto darbo, o ne ieškoti post factum pateisinimų.
| Rezultatas | Veiksmas |
|---|---|
| Derintas modelis laimi kokybe + kainomis | Diegti derintą modelį |
| Derintas modelis laimi kokybe, pralaimi kainomis | Įvertinti, ar kokybė pateisina papildomas išlaidas |
| Panašūs rezultatai | Likti prie bazinio modelio + prompto |
| Laimi bazinis modelis | Gerinti duomenis ir bandyti iš naujo |
Svarbiausi punktai
- Visada lygink su baziniu modeliu + optimizuotu promptu, o ne su basic promptu
- Naudok LLM vertinimą, kad automatizuotum kokybinį palyginimą
- Matuok išlaidas ir delsą, o ne tik kokybę
- Didesnis nei 60 % pagerėjimo rodiklis pateisina derinimą
- Jei derinimas nesuteikia akivaizdaus pagerėjimo, laikykis promptų inžinerijos