Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Vergleich mit dem Basismodell

Lektion 11 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Warum systematischer Vergleich wichtig ist
  2. Definition der Referenzlinie
  3. Generierung von nebeneinander stehenden Antworten
  4. Ein Modell von Drittanbietern als Richter
  5. Kostenvergleich
  6. Latenzvergleich
  7. Entscheidung basierend auf Ergebnissen
  8. Kernaussagen

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.

ErgebnisMaßnahme
FT gewinnt bei Qualität + KostenFeinabgestimmtes Modell bereitstellen
FT gewinnt bei Qualität, verliert bei KostenPrüfen, ob Qualität die zusätzlichen Kosten rechtfertigt
Ähnliche ErgebnisseBeim Basismodell + Prompt bleiben
Basismodell gewinntDaten 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