Vergelijken met het basismodel
Op deze pagina
Update 2 november 2026 — Beschikbaarheid fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd afgebouwd: vanaf 7 mei 2026 kunnen organisaties die dit nog nooit hebben gebruikt geen taken meer aanmaken; sinds 2 juli moet u binnen de laatste 60 dagen een fine-tuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.
Waarom systematische vergelijking essentieel is
Fine-tuning heeft een prijs: tijd voor datavoorbereiding, trainingskosten en onderhoudscomplexiteit. U moet aantonen dat uw fine-tuned model een meetbare verbetering biedt ten opzichte van het basismodel met een sterke prompt. Als het verschil marginaal is, weegt de inspanning van fine-tuning vaak niet op tegen het resultaat.
De verleiding bij deze oefening is groot om uw getrainde model te vergelijken met een slecht geïnstrueerd basismodel. Dat levert een vleiende maar waardeloze demonstratie op: u verslaat een tegenstander die u zelf heeft verzwakt. De enige eerlijke vergelijking stelt uw fine-tuned model tegenover het best mogelijke gebruik van het basismodel.
Definieer de basislijn
De basislijn is het basismodel met uw beste systeemprompt. Optimaliseer deze prompt voordat u vergelijkt. Concreet betekent dit dat u de regels opschrijft die u impliciet hebt geleerd via voorbeelden tijdens de fine-tuning: de rol, de toon, de verwachte lengte en hoe een uitwisseling wordt afgesloten. De onderstaande prompt doet precies dat voor een supportassistent; merk op dat het fine-tuned model dergelijke instructies niet nodig heeft, aangezien deze regels nu deel uitmaken van de gewichten.
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
Genereer side-by-side antwoorden
De volgende stap is om beide modellen exact dezelfde vragen te stellen en de gepaarde antwoorden te bewaren. Kies vragen die representatief zijn voor uw echte verkeer in plaats van schoolvoorbeelden: een klacht over levering, een aanvraag voor een procedure, ontevredenheid, een restitutieverzoek, een feitelijke vraag. Deze vijf categorieën maken het verschil in productie, niet de perfecte formulering.
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
)
Laat een derde model oordelen
Honderd paren met de hand lezen wordt snel ontmoedigend en het oordeel verslapt naarmate de vermoeidheid toeslaat. Een derde model, dat geen van beide antwoorden heeft geproduceerd, arbitreert elk paar op vier criteria en velt een globaal oordeel. Neutraliseer eerst de labels: de rechter ziet “Antwoord A” en “Antwoord B”, nooit welk model ze heeft geproduceerd, anders weegt het oordeel de modelnaam even zwaar als de tekst. Behandel vervolgens gevallen waarin de uitvoer niet parsebaar is; anders stopt één misvormd antwoord de hele campagne.
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]
Aggregeer deze oordelen nu tot één cijfer. Het verbeteringspercentage—het aandeel paren waarbij het fine-tuned model wint—wordt afgezet tegen vooraf gedefinieerde drempels: boven de 60% is de winst duidelijk; tussen 40% en 60% weegt u de winst af tegen de extra kosten; daaronder heeft uw fine-tuning zich niet bewezen en ligt het probleem bijna altijd in de data.
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)
Vergelijk kosten
Kwaliteit is slechts de helft van de beslissing. Fine-tuning vermindert vaak het aantal input-tokens omdat de lange prompt overbodig wordt, maar elke token die op een fine-tuned model wordt gefactureerd kost meer. Deze twee effecten werken in tegenovergestelde richting en alleen de berekening geeft de doorslag. De onderstaande functie zet ze tegenover elkaar over een maand verkeer: een prompt die daalt van 500 naar 50 tokens compenseert ruimschoots een verdubbelde input-tarief, maar dat zou niet gelden bij een al korte basisprompt.
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
)
Vergelijk latentie
Het inkorten van een prompt met enkele honderden tokens beïnvloedt ook de responstijd, een criterium dat uw gebruikers opmerken lang voordat ze tonale finesse waarnemen. Meet de latentie op dezelfde vragen die voor de kwalitatieve vergelijking zijn gebruikt, buiten piekuren, en herhaal de meting meerdere keren: een enkele waarde weerspiegelt meestal alleen de netwerksituatie op het moment van testen.
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
Beslis op basis van resultaten
Kruis nu kwaliteit en kosten. Elke combinatie vraagt om een andere beslissing en het meest ongemakkelijk blijft het middenterrein: wanneer de twee modellen gelijk zijn, moet u reeds betaald werk loslaten in plaats van achteraf rechtvaardiging te zoeken.
| Resultaat | Actie |
|---|---|
| FT wint op kwaliteit + kosten | Implementeer het fine-tuned model |
| FT wint op kwaliteit, verliest op kosten | Evalueer of de kwaliteit de extra kosten rechtvaardigt |
| Gelijkwaardige resultaten | Blijf bij basismodel + prompt |
| Basis wint | Verbeter uw data en probeer opnieuw |
Belangrijkste punten
- Vergelijk altijd met een basismodel + geoptimaliseerde prompt, niet met een basisprompt
- Gebruik LLM-oordeel om kwalitatieve vergelijking te automatiseren
- Meet kosten en latentie, niet alleen kwaliteit
- Een verbeteringspercentage van 60%+ rechtvaardigt fine-tuning
- Als fine-tuning geen duidelijke verbetering biedt, blijf dan bij prompt engineering