Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Feinabstimmung über die API starten

Lektion 5 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Überblick über den Prozess
  2. SDK installieren und konfigurieren
  3. Dateien hochladen
  4. Feinabstimmungsauftrag erstellen
  5. Fortschritt verfolgen
  6. Nutzung des feinabgestimmten Modells
  7. Verwaltung Ihrer Aufträge
  8. Kosten und Dauer
  9. Kernaussagen

Update vom 2. November 2026 — Verfügbarkeit der Feinabstimmung. Die Selbstbedienungsfunktion für Feinabstimmungen bei OpenAI wird schrittweise eingestellt: Ab dem 7. Mai 2026 können Organisationen, die noch nie einen Feinabstimmungsauftrag 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 Aufträge 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.

Überblick über den Prozess

Ihre Daten sind bereit, validiert und in Trainings- und Validierungsdatensätze aufgeteilt. Der eigentliche Trainingsschritt reduziert sich auf drei Schritte: Laden Ihrer Datendatei hoch, Erstellen eines Feinabstimmungsauftrags und Warten auf den Abschluss des Trainings. Alles läuft über das offizielle Python-SDK, und der Code passt in etwa dreißig Zeilen – die meiste Arbeit wurde bereits upstream erledigt.

SDK installieren und konfigurieren

Der Client wird ohne Argumente initialisiert: Er liest automatisch die Umgebungsvariable OPENAI_API_KEY.

# Installation
# pip install openai

from openai import OpenAI

# Der Client verwendet automatisch die Umgebungsvariable OPENAI_API_KEY
client = OpenAI()

Stellen Sie sicher, dass diese Variable vor dem Ausführen des Skripts gesetzt ist, sonst wird die Initialisierung beim ersten Aufruf fehlschlagen. In der Produktion sollten Sie den Schlüssel niemals im Code fest codieren: Ein im Klartext geschriebener Schlüssel landet in der Git-Geschichte, und das Entfernen desselben nachträglich ist weitaus kostspieliger als die Lektüre aus der Umgebung ab Tag eins.

Dateien hochladen

Das Hochladen verwendet purpose="fine-tune", was OpenAI mitteilt, dass die Datei für das Training bestimmt ist, und die entsprechenden Formatprüfungen auslöst. Laden Sie die Validierungsdatei sofort hoch: Sie ist technisch optional, aber ohne sie läuft das Training blind, da kein Validierungsverlust während des Auftrags das Überanpassen signalisiert.

# Trainingsdatei hochladen
training_file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"Datei-ID: {training_file.id}")
print(f"Status: {training_file.status}")

# Optional: Validierungsdatei hochladen
validation_file = client.files.create(
    file=open("validation_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"Validierungs-ID: {validation_file.id}")

Die Datei durchläuft eine Verarbeitungsphase auf der Seite von OpenAI. Warten Sie, bis der Status processed ist, bevor Sie den Auftrag starten: Ein Auftrag, der auf einer noch verarbeiteten Datei erstellt wird, wird fehlschlagen, und Sie werden einige Minuten damit verbringen, nach einer nicht existierenden Ursache in Ihrer JSONL zu suchen.

Feinabstimmungsauftrag erstellen

job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    validation_file=validation_file.id,  # optional, aber empfohlen
    model="gpt-5.6-luna",  # oder "gpt-5.6-luna"
    suffix="my-assistant-v1"  # Suffix zur Identifizierung Ihres Modells
)

print(f"Auftrags-ID: {job.id}")
print(f"Status: {job.status}")
print(f"Basismodell: {job.model}")

Der Parameter suffix wird dem Namen Ihres feinabgestimmten Modells angehängt: Mit "my-assistant-v1" wird das resultierende Modell ft:gpt-5.6-luna:your-org::my-assistant-v1:xxxxxxxx genannt. Gewöhnen Sie sich an, hier den Anwendungszweck und eine Versionsnummer anzugeben. Wenn drei Modelle in Ihrem Konto koexistieren, ist dies die einzige Möglichkeit, zu erkennen, welches Modell was tut, ohne die Konsole zu öffnen.

Fortschritt verfolgen

Ein Auftrag durchläuft mehrere Status nacheinander, und retrieve liefert Ihnen den aktuellen Status jederzeit.

# Status des Auftrags abrufen
job = client.fine_tuning.jobs.retrieve(job.id)
print(f"Status: {job.status}")
# Mögliche Status: validating_files, queued, running, succeeded, failed, cancelled

Der Status allein bleibt lakonisch. Ereignisse hingegen erzählen die Geschichte: Dateivalidierung, Start, schrittweiser Fortschritt, Ende.

# Ereignisse des Auftrags anzeigen
events = client.fine_tuning.jobs.list_events(
    fine_tuning_job_id=job.id,
    limit=20
)

for event in events.data:
    print(f"[{event.created_at}] {event.message}")

Statt retrieve alle fünf Minuten manuell aufzurufen, wickeln Sie das Warten in eine Schleife ein, die die Kontrolle zurückgibt, sobald der Auftrag einen Endzustand erreicht. Beachten Sie, dass die drei Exit-Fälle separat behandelt werden: Ein abgebrochener Auftrag ist kein fehlgeschlagener Auftrag, und Sie werden sie in Ihren Protokollen unterscheiden wollen.

import time

def track_job(client: OpenAI, job_id: str, interval: int = 30):
    """Verfolgt einen Feinabstimmungsauftrag bis zum Abschluss."""
    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)
        print(f"Status: {job.status}")

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

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

        if job.status == "cancelled":
            print("Auftrag abgebrochen.")
            return job

        time.sleep(interval)

# Verwendung
final_job = track_job(client, job.id)

Nutzung des feinabgestimmten Modells

Sobald der Auftrag erfolgreich abgeschlossen ist, wird Ihr Modell genau wie ein Standardmodell aufgerufen. Nur der Wert, der an model übergeben wird, ändert sich, was bedeutet, dass der Wechsel zu Ihrem benutzerdefinierten Modell in einer bestehenden Anwendung im Wesentlichen das Ändern einer Konfigurationsvariable bedeutet.

response = client.responses.create(
    model=final_job.fine_tuned_model,  # z. B. "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
    input="Hallo, ich habe ein Problem mit meiner Bestellung."
)

print(response.output_text)

Verwaltung Ihrer Aufträge

Zwei Aufrufe reichen aus, um alles zu verwalten: Auflisten, was existiert, und Unterbrechen, was läuft. Die Abbrechung ist nützlich, sobald die Überwachung zeigt, dass das Training aus dem Ruder läuft – es gibt keinen Sinn, für Tokens zu zahlen, von denen Sie bereits wissen, dass sie ein schlechtes Modell produzieren werden.

# Alle Feinabstimmungsaufträge auflisten
jobs = client.fine_tuning.jobs.list(limit=10)
for j in jobs.data:
    print(f"{j.id} | {j.status} | {j.model} | {j.fine_tuned_model}")

# Einen laufenden Auftrag abbrechen
client.fine_tuning.jobs.cancel(job.id)

Kosten und Dauer

Das Training wird nach der Anzahl der verarbeiteten Tokens berechnet. Die Dauer hängt hingegen von der Größe Ihrer Daten und der Anzahl der Epochen ab.

DatensatzgrößeTrainingsdauer
50 BeispieleEinige Minuten
500 Beispiele15 bis 30 Minuten
5.000 Beispiele1 bis 2 Stunden

Diese Größenordnungen helfen Ihnen hauptsächlich, Ihren Arbeitszyklus zu dimensionieren: Bei einigen Minuten pro Durchlauf iterieren Sie in derselben Sitzung; bei zwei Stunden planen Sie. Die genauen Preise variieren je nach gewähltem Modell; prüfen Sie die OpenAI-Preissseite für aktuelle Tarife.

Kernaussagen

  • Der Arbeitsablauf ist: Datei hochladen, Auftrag erstellen, warten, Modell nutzen
  • Fügen Sie ein beschreibendes suffix hinzu, um Ihre Modelle leicht zu identifizieren
  • Verwenden Sie immer eine Validierungsdatei, um die Qualität zu bewerten
  • Das feinabgestimmte Modell wird über die API genau wie das Basismodell verwendet
  • Bewahren Sie Ihre Auftrags- und Modell-IDs auf – Sie werden sie für die Versionierung benötigen