Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Training-Monitoring

Lektion 7 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Warum Training überwachen
  2. Die zwei zu lesenden Metriken
  3. Ereignisverfolgung über die API
  4. Checkpoints und Zwischenresultate
  5. Wann stoppen
  6. Ein zusammenfassender Bericht pro Lauf
  7. Kernaussagen

Update vom 2. November 2026 — Verfügbarkeit des Feinabstimmens. Das selbstbediente Feinabstimmungsdienst von OpenAI wird schrittweise eingestellt: Seit 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 Kunden neue Aufgaben 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.

Warum Training überwachen

Das Starten einer Feinabstimmungsaufgabe und das anschließende Vergessen führt zu einem fertigen Zustand: Eine Stunde später entdecken Sie ein Modell, ohne zu wissen, was dazwischen passiert ist. Durch die Beobachtung von Metriken während des Trainings erkennen Sie Probleme frühzeitig, entscheiden sich, Hyperparameter anzupassen, bevor Ihr gesamtes Budget verbrannt wird, und verstehen vor allem, warum eine Ausführung eine andere übertraf. Monitoring verwandelt eine Reihe von Versuchen in eine Ingenieursdisziplin.

Die zwei zu lesenden Metriken

Trainingsverlust (Training loss) misst, wie falsch das Modell auf den Trainingsdaten ist – den Daten, die es gerade aufnimmt. Er sollte über die Schritte hinweg abnehmen: Das ist das Zeichen dafür, dass Lernen stattfindet. Ein Verlust, der stagniert oder wieder ansteigt, deutet auf ein Problem hin, meist eine schlecht kalibrierte Lernrate oder einen zu heterogenen Korpus.

Validierungsverlust (Validation loss) misst die Leistung auf Daten, die das Modell während des Trainings noch nie gesehen hat – die Datei, die Sie während der Aufteilung beiseitegelegt haben. Dies ist die zuverlässigste Metrik zur Bewertung der tatsächlichen Qualität Ihres Modells, da es die einzige ist, die das Modell nicht durch Auswendiglernen verbessern kann. Ihre gemeinsame Entwicklung liefert die Diagnose.

Trainingsverlust Validierungsverlust Diagnose
Abnehmend Abnehmend Alles in Ordnung, weitermachen
Abnehmend Ansteigend Überanpassung (Overfitting) – Epochen reduzieren
Stagnierend Stagnierend Unteranpassung (Underfitting) – Lernrate erhöhen
Oszillierend Oszillierend Instabilität – Lernrate reduzieren

Die zweite Zeile ist diejenige, die in der Produktion am meisten kostet: Ein Trainingsverlust, der weiter abnimmt, während der Validierungsverlust wieder ansteigt, beschreibt ein Modell, das Ihre Beispiele auswendig lernt. Auf dem Papier scheint alles zu verbessern; in der Realität verschlechtert jeder zusätzliche Schritt die Fähigkeit des Modells, eine Frage zu beantworten, die es noch nie gesehen hat.

Ereignisverfolgung über die API

Die API sendet keine Benachrichtigungen: Sie müssen die Aufgabe in regelmäßigen Abständen abfragen. Der folgende Schleifenablauf holt neue Ereignisse, zeigt sie in chronologischer Reihenfolge an, ohne bereits gezeigte wiederzugeben, und gibt die Kontrolle zurück, sobald die Aufgabe einen Endzustand erreicht.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Überwacht eine Aufgabe in Echtzeit."""
    last_event = None

    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)

        # Neue Ereignisse abrufen
        events = client.fine_tuning.jobs.list_events(
            fine_tuning_job_id=job_id,
            limit=50
        )

        for event in reversed(events.data):
            if last_event and event.id == last_event:
                continue
            print(f"[{event.created_at}] {event.message}")

        if events.data:
            last_event = events.data[0].id

        if job.status in ("succeeded", "failed", "cancelled"):
            print(f"\nAufgabe abgeschlossen: {job.status}")
            if job.status == "succeeded":
                print(f"Modell: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Verwendung
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Ereignisse enthalten nicht nur Textnachrichten: Sie tragen auch Verlustwerte für jeden Schritt. Das Extrahieren dieser Werte ermöglicht es Ihnen, eine Kurve zu zeichnen, anstatt Logzeilen zu lesen, und auf einer Kurve erkennen Sie einen Validierungsverlustspiegel auf einen Blick.

def extract_metrics(job_id: str) -> dict:
    """Extrahiert Verlustmetriken aus einer abgeschlossenen Aufgabe."""
    events = client.fine_tuning.jobs.list_events(
        fine_tuning_job_id=job_id,
        limit=200
    )

    training_losses = []
    validation_losses = []

    for event in events.data:
        data = event.data
        if data and "train_loss" in str(data):
            training_losses.append(data)
        if data and "valid_loss" in str(data):
            validation_losses.append(data)

    return {
        "training": training_losses,
        "validation": validation_losses
    }

Checkpoints und Zwischenresultate

OpenAI speichert Checkpoints während des Trainings. Wenn die Aufgabe fehlschlägt oder Sie sie abbrechen, können Sie manchmal einen nutzbaren Zwischen-Checkpoint wiederherstellen – mit anderen Worten, eine unterbrochene Ausführung ist nicht zwingend eine verlorene Ausführung. Dies ist auch ein wertvoller Ausweg bei späten Überanpassungen: Der Checkpoint, der vor dem Validierungsverlustspiegel erstellt wurde, kann besser sein als das finale Modell.

# Checkpoints für eine Aufgabe auflisten
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Schritt {cp.step_number}")
    print(f"  Modell: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Trainingsverlust: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Validierungsverlust: {cp.metrics.valid_loss:.4f}")

Wann stoppen

Drei Signale rechtfertigen das Unterbrechen einer laufenden Trainingseinheit. Das erste ist ein Validierungsverlust, der über mehrere Schritte hinweg ansteigt, nicht nur bei einem einzelnen Wert: Ein isolierter Wert ist Rauschen, ein Trend über fünf Punkte ist Überanpassung. Das zweite ist ein Trainingsverlust, der nahe bei null liegt, was bedeutet, dass das Modell Ihre Beispiele wortwörtlich reproduziert und nichts mehr von ihnen zu lernen hat. Das dritte ist prosaischer: Ihre Tests verbessern sich von einem Checkpoint zum nächsten nicht, und jeder zusätzliche Schritt erhöht nur die Rechnung.

# Wenn Sie ein Problem erkennen, die Aufgabe abbrechen
client.fine_tuning.jobs.cancel(job.id)
print("Aufgabe abgebrochen. Passen Sie Ihre Daten oder Hyperparameter an und starten Sie neu.")

Ein zusammenfassender Bericht pro Lauf

Beenden Sie jede Trainingseinheit mit der Erstellung eines handlungsorientierten Aufzeichnungsprotokolls. Die folgende Funktion sammelt in einer einzigen Ausgabe die Aufgaben-ID, das Basismodell, die verwendeten Epochen, die Anzahl der trainierten Tokens und Metriken aus dem letzten Checkpoint zusammen. Fügen Sie diese Berichte in Ihr Laufprotokoll ein: In einem Monat werden sie Ihnen sagen, warum Sie diese Version beibehielten und nicht eine andere.

def job_report(job_id: str):
    """Generiert einen zusammenfassenden Bericht für die Aufgabe."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Aufgabe: {job.id}")
    print(f"Basismodell: {job.model}")
    print(f"Status: {job.status}")
    print(f"Epochen: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Feinabgestimmtes Modell: {job.fine_tuned_model}")
        print(f"Trainierte Tokens: {job.trained_tokens}")

    if job.status == "failed":
        print(f"Fehler: {job.error}")

    # Checkpoints
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Neuester Checkpoint: Schritt {latest.step_number}")
        if latest.metrics:
            print(f"  Trainingsverlust: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Kernaussagen

  • Überwachen Sie immer den Validierungsverlust – er ist Ihr echter Qualitätsindikator.
  • Wenn der Validierungsverlust ansteigt, überpassen Sie das Modell: Reduzieren Sie die Epochen.
  • Checkpoints ermöglichen die Wiederherstellung eines Zwischenzustands.
  • Automatisieren Sie das Monitoring für langlaufende Aufgaben.
  • Dokumentieren Sie Metriken aus jedem Lauf, um Ihre Iterationen zu vergleichen.