Vertaile perusmalliin
Tällä sivulla
Päivitys 2. marraskuuta 2026 — Hienosäädön saatavuus. OpenAI:n itsepalveluhienosäätö on poistumassa: 7. toukokuuta 2026 alkaen organisaatiot, jotka eivät ole koskaan käyttäneet sitä, eivät voi enää luoda tehtäviä; 2. heinäkuuta lähtien sinun on täytynyt käyttää hienosäädettyä mallia viimeisen 60 päivän aikana; ja 6. tammikuuta 2027 alkaen mikään asiakas ei voi käynnistää uusia tehtäviä. Jo koulutetut mallit pysyvät käytössä, kunnes niiden perusmalli poistetaan käytöstä. Tämä kurssi on edelleen hyödyllinen olemassa olevan mallin ymmärtämiseen ja hyödyntämiseen; uusissa projekteissa priorisoi kehotetekniikkaa, RAG:ia ja arviointia.
Miksi systemaattinen vertailu on tärkeää
Hienosäädöllä on hintansa: datan valmisteluaika, koulutuskulut ja ylläpidon monimutkaisuus. Sinun on osoitettava, että hienosäädetty mallisi tarjoaa mitattavan parannuksen verrattuna perusmalliin, jota on ohjeistettu erinomaisella kehotteella. Jos ero on marginaalinen, hienosäätö ei välttämättä ole vaivan arvoista.
Kiusaus tässä harjoituksessa on verrata koulutettua malliasi huonosti ohjeistettuun perusmalliin. Se luo imartelevan mutta arvottoman demonstraation: olet voittanut vastustajan, jonka heikensit itse. Ainoa rehellinen vertailu asettaa hienosäädetyn mallisi vastakkain perusmallin parhaan mahdollisen käytön kanssa.
Määritä vertailukohta
Vertailukohta on perusmalli parhaalla järjestelmäkehotteellasi. Optimoi tämä kehote ennen vertailua. Konkreettisesti tämä tarkoittaa niiden sääntöjen kirjaamista, jotka opetit epäsuorasti esimerkein hienosäädön aikana: rooli, sävy, odotettu pituus ja tapa päättää vuorovaikutus. Alla oleva kehote tekee juuri tämän tukiasistentille; huomaa, että hienosäädetty malli ei tarvitse tällaisia ohjeita, sillä nämä säännöt ovat nyt osa sen painoarvoja.
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
Luo rinnakkaisia vastauksia
Seuraava vaihe on kysyä molemmilta malleilta täsmälleen samoilla kysymyksillä ja säilyttää vastausparit. Valitse kysymykset, jotka edustavat todellista liikennettäsi äläkä oppikirjatapauksia: toimitusvalitus, menettelypyyntö, tyytymättömyys, hyvityspyyntö, faktakysymys. Nämä viisi ryhmää ratkaisevat eron tuotannossa, ei täydellinen muotoilu.
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
)
Pyydä kolmatta mallia tuomitsemaan
Sadan parin lukeminen käsin muuttuu nopeasti lannistavaksi, ja arvostelukyvyn heikkeneminen väsymyksen myötä on väistämätöntä. Kolmas osapuoli, joka ei ole tuottanut kumpaakaan vastausta, arbitroi jokaisen parin neljän kriteerin perusteella ja antaa yleisen tuomion. Ensiksi neutraloi tunnisteet: tuomari näkee ”Vastaus A” ja ”Vastaus B”, ei koskaan sitä, kumpi malli ne tuotti, muuten sen tuomio painottaa mallin nimeä yhtä paljon kuin tekstiä. Seuraavaksi käsittele tapaukset, joissa tuloste ei ole jäsennettävissä; muuten yksi vioittunut vastaus pysäyttää koko kampanjan.
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]
Nyt aggregoi nämä tuomiot yhdeksi luvuksi. Parannusaste – osuus pareista, joissa hienosäädetty malli voittaa – luetaan ennalta määriteltyjä kynnysarvoja vasten: yli 60 %, hyöty on selkeä; 40 % ja 60 % välillä, punnitse hyötyä lisäkustannuksiin nähden; alle sen, hienosäätösi ei ole osoittanut arvoaan, ja ongelma on lähes aina datassa.
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)
Vertaile kustannuksia
Laatu on vain puoli päätöksestä. Hienosäätö vähentää usein syöttötokeneita, sillä pitkä kehote muuttuu tarpeettomaksi, mutta jokainen hienosäädetystä mallista laskutettu token maksaa enemmän. Nämä kaksi vaikutusta vetävät vastakkaisiin suuntiin, ja vain laskelma ratkaisee. Alla oleva funktio asettaa ne vastakkain kuukauden liikenteelle: kehotteen lyhentyminen 500:sta 50 tokeniin kompensoi enemmän kuin kaksinkertaistuneen syöttöhinnan, mutta tämä ei päde jo valmiiksi lyhyeen peruskehotteeseen.
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
)
Vertaile viivettä
Kehotteen lyhentäminen useilla sadoilla tokeneilla vaikuttaa myös vasteaikaan, kriteeriin, jonka käyttäjäsi huomaavat kauan ennen sävyn hienovaraisuuksia. Mittaa viive samoilla kysymyksillä, joita käytit laadulliseen vertailuun, ruuhka-aikojen ulkopuolella, ja toista mittaus useita kertoja: yksittäinen arvo heijastaa lähinnä verkon tilaa testihetkellä.
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 päätös tulosten perusteella
Nyt ristiinviittaa laatu ja kustannukset. Jokainen yhdistelmä vaatii erilaisen päätöksen, ja epämukavin on keskiväli: kun kaksi mallia ovat tasavertaisia, sinun on hylättävä jo maksettu työ sen sijaan, että etsisit jälkikäteen oikeutusta.
| Tulos | Toimenpide |
|---|---|
| Hienosäädetty voittaa laadussa + kustannuksissa | Ota hienosäädetty malli käyttöön |
| Hienosäädetty voittaa laadussa, häviää kustannuksissa | Arvioi, oikeuttaako laatu lisäkustannukset |
| Samanlaiset tulokset | Pysy perusmallissa + kehotteessa |
| Perusmalli voittaa | Paranna dataasi ja yritä uudelleen |
Keskeiset asiat
- Vertaa aina perusmalliin + optimoituun kehotteeseen, älä peruskehotteeseen
- Käytä LLM-arviointia laadullisen vertailun automatisointiin
- Mittaa kustannukset ja viive, ei vain laatua
- Yli 60 %:n parannusaste oikeuttaa hienosäädön
- Jos hienosäätö ei tarjoa selkeää parannusta, pysy kehotetekniikassa