Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Kosten und Optimierung

Lektion 15 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Verständnis der Kostenstruktur
  2. Die Trainingskosten
  3. Die Inferenzkosten
  4. Eingabetokens reduzieren
  5. Balance zwischen Datensatzgröße und Epochen
  6. Ausgabenüberwachung in der Produktion
  7. Begründung der Investition
  8. Kernaussagen

Update vom 2. November 2026 — Verfügbarkeit des Feinabstimmens. Das Selbstbedienungs-Feinabstimmungsdienst von OpenAI wird schrittweise eingestellt: Seit dem 7. Mai 2026 können Organisationen, die dies noch nie genutzt haben, keine Jobs mehr 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 Kunden neue Jobs starten. 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 sollten Sie Prompt Engineering, RAG und Evaluierungen priorisieren.

Verständnis der Kostenstruktur

Das Feinabstimmen bei OpenAI umfasst zwei Arten von Kosten: eine einmalige Trainingskosten und wiederkehrende Inferenzkosten. Das Verständnis und die Optimierung dieser Kosten sind für eine profitable Bereitstellung unerlässlich. Der Unterschied liegt nicht nur in der Buchhaltung: Die erste ist eine einmalige Entscheidung, die vor dem Start des Jobs getroffen wird und sich nicht ändert; die zweite begleitet Sie jeden Monat und wächst mit Ihrem Verkehr. Ein Team, das über Trainingskosten verhandelt, während ein Prompt mit tausend Tokens auf fünftausend täglichen Anfragen läuft, kämpft im falschen Feld.

Die Trainingskosten

Das Training wird pro verarbeiteten Token berechnet, und diese Zahl hängt direkt von zwei Variablen ab, die Sie kontrollieren: die Größe Ihres Datensatzes und die Anzahl der Durchläufe darüber.

Trainingskosten = Gesamt-Token × Anzahl_Epochen × Preis_pro_Trainingstoken

Mit dieser Formel können Sie die Rechnung abschätzen, bevor Sie etwas starten. Die folgende Funktion scannt die JSONL-Datei und approximiert die Token-Anzahl basierend auf der Nachrichtenlänge – die Schätzung von einem Token pro vier Zeichen in Französisch ist grob, aber sie reicht aus, um einen Job im Bereich von wenigen Dollar von einem zu unterscheiden, der mehrere Hundert kostet. Machen Sie es zur Gewohnheit, dies systematisch durchzuführen: Ein Vorbereitungsfehler, der Ihren Datensatz verdreifacht, zeigt sich sofort im Ergebnis.

import json

def estimate_training_cost(
    jsonl_file: str,
    n_epochs: int,
    price_per_million_tokens: float
) -> dict:
    """Schätzt die Trainingskosten, bevor der Job gestartet wird."""
    total_tokens = 0

    with open(jsonl_file, "r") as f:
        num_examples = 0
        for line in f:
            num_examples += 1
            obj = json.loads(line)
            for msg in obj["messages"]:
                # Grobe Schätzung: 1 Token ~ 4 Zeichen in Französisch
                total_tokens += len(msg["content"]) // 4

    training_tokens = total_tokens * n_epochs
    cost = training_tokens * price_per_million_tokens / 1_000_000

    return {
        "examples": num_examples,
        "tokens_per_pass": total_tokens,
        "epochs": n_epochs,
        "total_tokens": training_tokens,
        "estimated_cost": f"${cost:.2f}"
    }

result = estimate_training_cost(
    "training_data.jsonl",
    n_epochs=3,
    price_per_million_tokens=8.0  # aktuellen Preis prüfen
)

for k, v in result.items():
    print(f"{k}: {v}")

Die Inferenzkosten

Die Inferenz wird pro Aufruf berechnet, basierend auf Eingabe- und Ausgabetokens, und feinabgestimmte Modelle haben im Allgemeinen eine etwas höhere Rate als das Basismodell. Diese Einheitenaufschlag führt oft zu Zögern, was fälschlicherweise geschieht: Er gilt für weit weniger Tokens, da das zuvor in einem langen System-Prompt beschriebene Verhalten nun im Modell integriert ist. Die Berechnung unten stellt beide Szenarien nebeneinander für einen Monat mit identischem Verkehr dar, wobei der Prompt von 800 auf 100 Tokens sinkt und die Raten verdoppelt werden. Passen Sie die Parameter mit Ihren eigenen Zahlen an, bevor Sie Schlüsse ziehen: Bei Nutzung, bei der der Prompt bereits kurz war, kehrt sich das Verhältnis um.

def monthly_cost(
    requests_per_day: int,
    avg_input_tokens: int,
    avg_output_tokens: int,
    price_input_per_million: float,
    price_output_per_million: float
) -> float:
    """Berechnet die monatlichen Inferenzkosten."""
    requests_month = requests_per_day * 30
    input_cost = requests_month * avg_input_tokens * price_input_per_million / 1_000_000
    output_cost = requests_month * avg_output_tokens * price_output_per_million / 1_000_000
    return input_cost + output_cost

# Szenario: Basismodell mit langem Prompt
base_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=800,    # langer System-Prompt + Frage
    avg_output_tokens=200,
    price_input_per_million=0.15,
    price_output_per_million=0.60
)

# Szenario: Feinabgestimmtes Modell mit minimalem Prompt
ft_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=100,    # kurzer Prompt, Verhalten integriert
    avg_output_tokens=200,
    price_input_per_million=0.30,  # höhere FT-Rate
    price_output_per_million=1.20
)

print(f"Monatliche Basiskosten: ${base_cost:.2f}")
print(f"Monatliche feinabgestimmte Kosten: ${ft_cost:.2f}")
print(f"Differenz: ${ft_cost - base_cost:+.2f}")

Eingabetokens reduzieren

Der wichtigste Hebel für Einsparungen mit einem feinabgestimmten Modell ist die Reduzierung des Prompts. Jede Anweisung, die Sie entfernen können, weil das Modell sie internalisiert hat, ist ein Gewinn, der bei jedem Aufruf wiederholt wird, bis der Dienst sein Lebensende erreicht. Die folgende Tabelle gibt die beobachteten Größenordnungen je nach Grad der Integration wieder.

Ansatz Eingabetokens Einsparungen
Basismodell + detaillierter Prompt 500-1000 Tokens Referenz
Feinabgestimmt + minimaler Prompt 50-100 Tokens 80-90% bei Eingabe
Feinabgestimmt + kein System-Prompt 20-50 Tokens 95% bei Eingabe

Entfernen Sie diese Anweisungen nicht alle auf einmal in der Hoffnung, dass alles funktioniert. Entfernen Sie sie in Gruppen und führen Sie nach jeder Entfernung Ihren Testdatensatz erneut durch: Sie werden feststellen, dass einige Regeln perfekt gelernt wurden, während andere, die in Ihren Beispielen weniger vertreten sind, im Prompt bleiben müssen.

Balance zwischen Datensatzgröße und Epochen

Mehr Daten ergeben ein besseres Modell, aber auch höhere Trainingskosten, und die Renditen nehmen ab. Der Übergang von hundert auf dreihundert Beispiele ändert meist viel; der Übergang von tausend auf dreitausend ändert wenig, bei dreimal dem Preis. Trainieren Sie mehrere Größen, messen Sie die erreichte Qualität und beziehen Sie diese auf die Kosten, um Ihren Break-Even-Punkt zu finden.

def find_optimal(results_by_size: dict):
    """Identifiziert die optimale Datensatzgröße."""
    print("Datensatzgröße | Qualitätspunktzahl | Trainingskosten")
    print("-" * 55)

    best_ratio = 0
    optimal_size = 0

    for size, data in sorted(results_by_size.items()):
        score = data["score"]
        cost = data["cost"]
        ratio = score / cost if cost > 0 else 0

        print(f"{size:>14} | {score:>13.2f} | {cost:>17.2f} $")

        if ratio > best_ratio:
            best_ratio = ratio
            optimal_size = size

    print(f"\nOptimale Größe: {optimal_size} Beispiele")

Die Wahl des Basismodells wiegt auf derselben Skala. Luna ist günstiger als Terra, sowohl beim Training als auch bei der Inferenz: Beginnen Sie immer mit dem günstigsten Modell und wechseln Sie nur dann nach oben, wenn die erreichte Qualität unzureichend ist. Prüfen Sie in der OpenAI-Dokumentation, welche Modelle für das Feinabstimmen eligible sind – die Liste ändert sich mit jeder Generation und deckt nie den gesamten Katalog ab. Dann gibt es die Anzahl der Epochen, da jeder zusätzliche Durchlauf die Trainingskosten mechanisch vervielfacht. Wenn 2 Epochen 95 % der Qualität von 4 Epochen liefern, ist die Entscheidung schnell.

Ausgabenüberwachung in der Produktion

Die vor dem Start erstellte Schätzung gilt nur für das Training. In der Produktion ist es der tatsächliche Verkehr, der die Kosten treibt, und er überrascht oft auf der positiven Seite. Ein Zähler, der bei jedem Aufruf gespeist wird und an ein monatliches Budget gebunden ist, warnt Sie, bevor die Rechnung es tut. Die 80%-Schwelle lässt Zeit zum Reagieren: Reduzieren Sie einen Prompt, begrenzen Sie Antwortlängen oder verschieben Sie einige Verkehr auf ein günstigeres Modell.

class CostTracker:
    """Echtzeit-Kostenüberwachung."""

    def __init__(self, monthly_budget: float):
        self.budget = monthly_budget
        self.spending = 0.0
        self.calls = 0

    def record(self, input_tokens: int, output_tokens: int,
               input_price: float, output_price: float):
        """Bucht die Kosten eines Aufrufs."""
        cost = (
            input_tokens * input_price / 1_000_000 +
            output_tokens * output_price / 1_000_000
        )
        self.spending += cost
        self.calls += 1

        # Warnung, wenn das Budget angenähert wird
        utilization = self.spending / self.budget * 100
        if utilization > 80:
            print(f"ALERT: {utilization:.1f}% des monatlichen Budgets verwendet")

    def report(self):
        """Verbrauchsbericht."""
        print(f"Aufrufe: {self.calls}")
        print(f"Ausgaben: ${self.spending:.2f}")
        print(f"Verbleibendes Budget: ${self.budget - self.spending:.2f}")
        if self.calls > 0:
            print(f"Durchschnittliche Kosten pro Aufruf: ${self.spending / self.calls:.4f}")

Begründung der Investition

Es bleibt die Frage, die Ihre Führung irgendwann oder bald stellen wird: Wie lange dauert es, bis sich das Training amortisiert? Die Berechnung bezieht eine einmalige Kosten auf einen monatlichen Nutzen, der Token-Einsparungen und den Wert hinzufügt, den Sie Qualitätsgewinnen zuweisen. Dieser zweite Begriff ist der kniffligste, und es ist besser, ihn bei Null zu belassen, als ihn zu erfinden: Eine Amortisation, die allein auf messbaren Einsparungen demonstriert wird, überzeugt mehr als eine großzügige Projektion.

def calculate_roi(
    training_cost: float,
    monthly_savings: float,
    quality_gain_value: float = 0
) -> dict:
    """Berechnet die Rendite der Investition für das Feinabstimmen."""
    monthly_benefit = monthly_savings + quality_gain_value
    payback_months = training_cost / monthly_benefit if monthly_benefit > 0 else float("inf")

    return {
        "training_cost": f"${training_cost:.2f}",
        "monthly_benefit": f"${monthly_benefit:.2f}",
        "payback": f"{payback_months:.1f} Monate",
        "annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
    }

Kernaussagen

  • Schätzen Sie die Trainingskosten, bevor Sie den Job starten
  • Der wichtigste Hebel für Einsparungen ist die Reduzierung der Eingabetokens
  • Beginnen Sie mit dem günstigsten Basismodell (Luna), bevor Sie zu Terra wechseln
  • Überwachen Sie Kosten in der Produktion mit Budgetwarnungen
  • Berechnen Sie die ROI einschließlich Qualitätsgewinnen und Token-Einsparungen