Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Iteration: Wann ein neues Fine-Tuning notwendig ist

Lektion 13 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Fine-Tuning ist ein iterativer Prozess
  2. Analysieren Sie Fehler, bevor Sie diese beheben
  3. Erkennen, wann zu iterieren ist
  4. Bereichern statt von vorne zu beginnen
  5. Kontinuierliches Fine-Tuning und seine Grenzen
  6. Der vollständige Zyklus
  7. Dokumentieren Sie jede Iteration
  8. Kernaussagen

Update vom 2. November 2026 – Verfügbarkeit von Fine-Tuning. Das Self-Service-Fine-Tuning von OpenAI wird schrittweise eingestellt: Seit dem 7. Mai 2026 können Organisationen, die noch nie ein Fine-Tuning-Job ausgeführt haben, keine neuen 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 eingestellt 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.

Fine-Tuning ist ein iterativer Prozess

Ihr erstes Fine-Tuning wird selten perfekt sein. Verbesserungen entstehen durch iterative Zyklen: Analysieren Sie Fehler, bereichern Sie Ihre Daten, trainieren Sie neu und bewerten Sie erneut. Diese Lektion lehrt Sie, wann und wie Sie effektiv iterieren können – und, ebenso wichtig, Situationen zu erkennen, in denen ein erneutes Training sinnlos wäre.

Analysieren Sie Fehler, bevor Sie diese beheben

Die natürliche Reflexion nach einer enttäuschenden Evaluation besteht darin, zufällig weitere Beispiele hinzuzufügen, in der Hoffnung, dass die Menge das Problem löst. Das ist der schnellste Weg, Ihr Trainingsbudget zu verbrennen, ohne Fortschritte zu erzielen. Beginnen Sie damit, jeden Fehler in eine Kategorie zu sortieren: falsches Format, unangemessener Ton, faktischer Fehler, unvollständige Antwort, abwegige Antwort oder reine Halluzination. Die resultierende Verteilung zeigt Ihnen, wo Sie Ihre Anstrengungen konzentrieren sollten, und offenbart oft eine Überraschung: Was Sie für ein Stilproblem hielten, stellt sich als ein Vollständigkeitsproblem heraus.

def analyze_errors(results: list[dict]) -> dict:
    """Kategorisiert Fehler des feinabgestimmten Modells."""
    categories = {
        "format": [],       # Falsches Antwortformat
        "tone": [],         # Unangemessener Ton
        "factual": [],      # Falsche Informationen
        "incomplete": [],   # Antwort zu kurz oder Elemente fehlen
        "off_topic": [],    # Beantwortet die Frage nicht
        "hallucination": [] # Erfindet Informationen
    }

    for r in results:
        if r.get("score", 5) < 3:
            # Klassifizieren Sie den Fehler (kann manuell oder durch ein LLM erfolgen)
            category = classify_error(r)
            categories[category].append(r)

    print("Verteilung der Fehler:")
    for cat, errors in categories.items():
        if errors:
            print(f"  {cat}: {len(errors)} Fälle")

    return categories

Überprüfen Sie im nächsten Schritt die Fälle innerhalb derselben Kategorie, um einen gemeinsamen Nenner zu finden. Stellen Sie sich bei jedem Fall die gleichen Fragen: Scheitert das Modell an einer bestimmten Art von Frage, gruppieren sich die Fehler um bestimmte Themen, oder liegt das Problem an den Daten oder den Hyperparametern? Fehler, die über alle Themen verstreut sind, aber immer derselben Natur sind, deuten auf einen Mangel an Beispielen hin; Fehler, die sich auf ein bestimmtes Gebiet konzentrieren, zeigen eine Lücke in der Abdeckung; und Antworten, die sich zu stark an den Trainingsbeispielen orientieren, unabhängig von der Frage, signalisieren Overfitting, das auf der Seite der Epochen korrigiert werden muss.

Erkennen, wann zu iterieren ist

Bestimmte Signale verlangen unmissverständlich eine neue Version, und jede erfordert eine andere Reaktion. Ein Modell, das auf einem Thema halluziniert, wird nicht durch das Zeigen weiterer korrekter Antworten zu diesem Thema behoben, sondern indem Sie es lehren, höflich abzulehnen, wenn es nicht weiß.

SignalMaßnahme
Wiederkehrende FormatfehlerFügen Sie weitere Beispiele mit dem korrekten Format hinzu
Modell halluziniert auf bestimmten ThemenFügen Sie Beispiele hinzu, in denen es höflich ablehnt
Overfitting erkanntEpochen reduzieren, Daten diversifizieren
Neue Anwendungsfälle abzudeckenFügen Sie Beispiele für diese Fälle hinzu
Gezieltes negatives BenutzerfeedbackWandeln Sie Feedback in korrigierte Beispiele um

Umgekehrt sollten Sie in mehreren Situationen von einem erneuten Training absehen. Wenn Fehler selten und nicht systematisch sind, bewältigt eine Anpassung des Prompts diese schneller und kostengünstiger. Wenn Beschwerden sich auf Latenz oder Wartezeiten beziehen, liegt das Problem in Ihrer Infrastruktur, und keine Menge an Training wird dies beheben. Wenn Sie seit der letzten Version nur eine Handvoll neuer Beispiele gesammelt haben, wird der erwartete Gewinn die Kosten des Laufs nicht decken. Und wenn ein neues Basismodell verfügbar wird, testen Sie es zunächst so, wie es ist: manchmal erreicht es von sich aus, ohne Training, was Ihre vorherige Version schwer zu liefern vermochte.

Bereichern statt von vorne zu beginnen

Inkrementelle Iteration bedeutet, gezielte Beispiele zu einem bestehenden Datensatz hinzuzufügen, ohne den Rest zu berühren. Dies ist die häufigste und einfachste Operation: Sie laden die aktuelle Datei, fügen die neuen Fälle an und schreiben alles im JSONL-Format neu. Die Endanzahl dient als Kontrolle – eine Gesamtzahl, die nicht der erwarteten Summe entspricht, deutet auf einen Datei-Lese-Fehler oder verlorene Zeilen hin.

import json

def enrich_dataset(
    existing_dataset: str,
    new_examples: list[dict],
    output: str
):
    """Fügt neue Beispiele zum bestehenden Datensatz hinzu."""
    # Laden der vorhandenen Daten
    with open(existing_dataset, "r") as f:
        existing = [json.loads(l) for l in f]

    # Zusammenfügen
    combined = existing + new_examples

    # Speichern
    with open(output, "w") as f:
        for ex in combined:
            f.write(json.dumps(ex, ensure_ascii=False) + "\n")

    print(f"Angereicherter Datensatz: {len(existing)} + {len(new_examples)} = {len(combined)}")

Korrektive Iteration ist noch wertvoller, da sie Ihre Fehler in Rohmaterial verwandelt. Jeder Fehler, der in der Produktion entdeckt wird, liefert eine echte Frage; Sie müssen nur die Antwort schreiben, die Sie gerne gesehen hätten, und das Paar wird zu einem Trainingsbeispiel. Beachten Sie, dass die schlechte Antwort nicht in das finale Beispiel geht: Sie hilft, den Fall zu dokumentieren und zu entscheiden, ob die Korrektur den Aufwand wert ist, aber das Modell lernt nur von der korrekten Version.

def error_to_example(
    question: str,
    bad_response: str,
    good_response: str,
    system_msg: str
) -> dict:
    """Verwandelt einen Fehler in ein Trainingsbeispiel."""
    return {
        "messages": [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": question},
            {"role": "assistant", "content": good_response}
        ]
    }

# Verwandeln Sie eine Charge von Fehlern
corrections = []
for error in detected_errors:
    correction = error_to_example(
        question=error["question"],
        bad_response=error["model_response"],
        good_response=error["corrected_response"],
        system_msg=SYSTEM_PROMPT
    )
    corrections.append(correction)

Kontinuierliches Fine-Tuning und seine Grenzen

Nichts hindert Sie daran, ein bereits feinabgestimmtes Modell erneut zu trainieren: Geben Sie einfach seine vollständige ID im Parameter model an, anstatt den Namen des Basismodells. Die Operation ist verlockend, da sie nur auf den neuen Daten trainiert.

# Feinabstimmen von einem bereits feinabgestimmten Modell
job_v2 = client.fine_tuning.jobs.create(
    training_file=new_file.id,
    model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx",  # v1-Modell als Basis
    suffix="my-assistant-v2"
)

Warnung: Kontinuierliches Fine-Tuning akkumuliert Verzerrungen. Nach 2–3 aufeinanderfolgenden Iterationen ist es oft besser, frisch vom Basismodell mit einem vollständigen, angereicherten Datensatz zu beginnen. Jede Ebene verstärkt die Eigenheiten der vorherigen, einschließlich solcher, die Sie nicht beabsichtigt haben, und das Modell antwortet am Ende mit einer Starrheit, die niemand explizit gelehrt hat.

Der vollständige Zyklus

Die Schritte unten bilden den Kreislauf, den Sie für jede Version wiederholen werden. Wenn Sie die häufigsten Fehler zuerst angehen, wird die nächste Version messbare Gewinne auf Ihrem Testdatensatz zeigen; wenn Sie sie in falscher Reihenfolge angehen, ergibt sich nur eine diffuse Verbesserung, die Sie Ihrem Team schwer rechtfertigen können.

1

Fehler sammeln

Identifizieren Sie Fälle, in denen das Modell in der Produktion oder während der Evaluation versagt.

2

Kategorisieren und priorisieren

Klassifizieren Sie Fehler nach Typ und bearbeiten Sie die häufigsten zuerst.

3

Korrektive Beispiele erstellen

Verwandeln Sie jeden Fehler in ein Trainingsbeispiel mit der korrekten Antwort.

4

Neu trainieren und neu evaluieren

Trainieren Sie die neue Version und vergleichen Sie sie mit der vorherigen auf demselben Testdatensatz.

Dokumentieren Sie jede Iteration

Nach vier oder fünf Versionen erinnert sich niemand daran, was v2 von v3 unterschied oder warum v4 verworfen wurde. Die systematische Aufzeichnung jedes Laufs – die Zusammensetzung des Datensatzes, die Quelle der neuen Beispiele, Hyperparameter, Ergebnisse und die getroffene Entscheidung – liefert Ihnen diese Informationen, wenn eine Regression Sie zwingt, Ihre Schritte zurückzuverfolgen. Achten Sie besonders auf die Quelle der neuen Beispiele: Nur diese wird Ihnen Monate später sagen, ob die Verschlechterung von einem schlecht gewählten Datenbatch stammt.

iteration_log = {
    "version": "v3",
    "date": "2026-04-02",
    "base_model": "gpt-5.6-luna",
    "dataset": {
        "train": 350,
        "validation": 45,
        "new_examples": 50,
        "new_examples_source": "Produktionsfehler Woche 12"
    },
    "hyperparameters": {
        "n_epochs": 3,
        "learning_rate_multiplier": "auto",
        "batch_size": "auto"
    },
    "results": {
        "validation_loss": 0.42,
        "precision_test": 0.91,
        "avg_csat": 4.3,
        "improvement_vs_v2": "+5% Präzision, +0,2 CSAT"
    },
    "decision": "Am 2026-04-03 in die Produktion deployed"
}

Kernaussagen

  • Fine-Tuning ist iterativ – planen Sie mehrere Zyklen ein
  • Kategorisieren Sie Fehler, bevor Sie diese in den Daten beheben
  • Wandeln Sie Benutzerfeedback in Trainingsbeispiele um
  • Nach 2–3 aufeinanderfolgenden Iterationen neu vom Basismodell starten
  • Dokumentieren Sie jede Iteration, um eine klare Historie zu erhalten