Vergleich mit dem Basismodell
Auf dieser Seite
Update vom 2. November 2026 — Verfügbarkeit des Feinabstimmens. Das Selbstbedienungs-Feinabstimmungsdienst von OpenAI wird schrittweise eingestellt: Ab dem 7. Mai 2026 können Organisationen, die dies noch nie genutzt haben, keine neuen Aufgaben erstellen; seit dem 2. Juli müssen Sie ein feinabgestimmtes Modell innerhalb der letzten 60 Tage verwendet haben; und ab dem 6. Januar 2027 können keine neuen Aufgaben mehr gestartet werden. Bereits trainierte Modelle bleiben nutzbar, bis ihr Basismodell zurückgezogen wird. Dieser Kurs bleibt nützlich, um ein bestehendes Modell zu verstehen und zu nutzen; für neue Projekte priorisieren Sie Prompt-Engineering, RAG und Evaluierungen.
Warum systematischer Vergleich wichtig ist
Feinabstimmung hat einen Preis: Zeit für die Datenvorbereitung, Trainingskosten und Wartungskomplexität. Sie müssen beweisen, dass Ihr feinabgestimmtes Modell eine messbare Verbesserung gegenüber dem Basismodell mit einem starken Prompt liefert. Wenn der Unterschied marginal ist, lohnt sich das Feinabstimmen möglicherweise nicht.
Die Versuchung in dieser Übung besteht darin, Ihr trainiertes Modell gegen ein schlecht instruiertes Basismodell zu stellen. Das ergibt eine schmeichelhafte, aber wertlose Demonstration: Sie haben einen Gegner besiegt, den Sie selbst geschwächt haben. Der einzige ehrliche Vergleich stellt Ihr feinabgestimmtes Modell gegen die beste mögliche Nutzung des Basismodells.
Definition der Referenzlinie
Die Referenzlinie ist das Basismodell mit Ihrem besten System-Prompt. Optimieren Sie diesen Prompt, bevor Sie vergleichen. Konkret bedeutet dies, die Regeln aufzuschreiben, die Sie implizit durch Beispiele während des Feinabstimmens gelehrt haben: die Rolle, der Ton, die erwartete Länge und wie ein Austausch beendet wird. Der folgende Prompt tut genau das für einen Support-Assistenten; beachten Sie, dass das feinabgestimmte Modell keine solchen Anweisungen benötigt, da diese Regeln nun Teil seiner Gewichte sind.
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
Generierung von nebeneinander stehenden Antworten
Der nächste Schritt besteht darin, beide Modelle auf genau denselben Fragen abzufragen und die gepaarten Antworten zu speichern. Wählen Sie Fragen, die repräsentativ für Ihren echten Datenverkehr sind, anstatt theoretischer Fälle: eine Beschwerde über eine Lieferung, eine Anfrage nach einem Verfahren, Unzufriedenheit, eine Rückerstattungsanfrage, eine faktische Frage. Diese fünf Kategorien machen den Unterschied in der Produktion, nicht die perfekte Formulierung.
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
)
Ein Modell von Drittanbietern als Richter
Das manuelle Lesen von hundert Paaren wird schnell entmutigend, und das Urteil schwindet, sobald die Müdigkeit einsetzt. Ein Modell von Drittanbietern, das weder Antwort erzeugt hat, bewertet jedes Paar nach vier Kriterien und fällt ein globales Urteil. Neutralisieren Sie zunächst die Labels: Der Richter sieht „Antwort A” und „Antwort B”, niemals, welches Modell sie erzeugt hat, sonst wird sein Urteil den Modellnamen so stark gewichten wie den Text. Behandeln Sie sodann Fälle, in denen die Ausgabe nicht lesbar ist; andernfalls stoppt eine einzige fehlerhafte Antwort die gesamte Kampagne.
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]
Fassen Sie diese Urteile nun in einer einzigen Zahl zusammen. Die Verbesserungsrate – der Anteil der Paare, bei denen das feinabgestimmte Modell gewinnt – wird an vordefinierten Schwellenwerten gemessen: Über 60 % deutet auf eine klare Verbesserung hin; zwischen 40 % und 60 % wiegen Sie den Gewinn gegen die zusätzlichen Kosten ab; darunter hat sich Ihr Feinabstimmung nicht bewährt, und das Problem liegt fast immer in den Daten.
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)
Kostenvergleich
Qualität ist nur die Hälfte der Entscheidung. Feinabstimmung reduziert oft die Eingabetokens, da der lange Prompt unnötig wird, aber jedes Token, das auf einem feinabgestimmten Modell berechnet wird, kostet mehr. Diese beiden Effekte ziehen in entgegengesetzte Richtungen, und nur die Berechnung entscheidet. Die Funktion unten stellt sie über einen Monat des Datenverkehrs gegeneinander: Ein Prompt, der von 500 auf 50 Tokens sinkt, überkompensiert mehr als eine Verdoppelung des Eingabepreises, aber das würde bei einem bereits kurzen Basisprompt nicht zutreffen.
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
)
Latenzvergleich
Das Kürzen eines Prompts um mehrere hundert Tokens wirkt sich auch auf die Antwortzeit aus, ein Kriterium, das Ihre Nutzer lange vor tonalen Feinheiten bemerken. Messen Sie die Latenz auf denselben Fragen, die für den qualitativen Vergleich verwendet wurden, außerhalb der Spitzenzeiten und wiederholen Sie die Messung mehrmals: Ein einzelner Wert spiegelt meist nur den Netzwerkzustand zum Zeitpunkt des Tests wider.
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
Entscheidung basierend auf Ergebnissen
Kreuzvergleichen Sie nun Qualität und Kosten. Jede Kombination erfordert eine andere Entscheidung, und die unangenehmste bleibt der Mittelweg: Wenn die beiden Modelle gleich sind, müssen Sie bereits bezahlte Arbeit aufgeben, anstatt nachträglich eine Rechtfertigung zu suchen.
| Ergebnis | Maßnahme |
|---|---|
| FT gewinnt bei Qualität + Kosten | Feinabgestimmtes Modell bereitstellen |
| FT gewinnt bei Qualität, verliert bei Kosten | Prüfen, ob Qualität die zusätzlichen Kosten rechtfertigt |
| Ähnliche Ergebnisse | Beim Basismodell + Prompt bleiben |
| Basismodell gewinnt | Daten verbessern und erneut versuchen |
Kernaussagen
- Vergleichen Sie immer mit einem Basismodell + optimiertem Prompt, nicht mit einem einfachen Prompt
- Nutzen Sie LLM-Bewertungen, um den qualitativen Vergleich zu automatisieren
- Messen Sie Kosten und Latenz, nicht nur Qualität
- Eine Verbesserungsrate von 60 %+ rechtfertigt Feinabstimmung
- Wenn Feinabstimmung keine klare Verbesserung bietet, bleiben Sie beim Prompt-Engineering