Einen feinabgestimmten Modell bereitstellen
Auf dieser Seite
Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation:
temperatureundtop_pwerden nur mit einem Reasoning-Effort vonnoneakzeptiert, während GPT-5.6-Modelle standardmäßig nachdenken (medium). Aufrufe, die diese Parameter festlegen, müssen daherreasoning={"effort": "none"}(API Responses) oderreasoning_effort="none"(Chat Completions) angeben. Quellen: Using GPT-6 · GPT-5.6 Terra.
Aktualisierung vom 2. November 2026 — Verfügbarkeit der Feinabstimmung. Der Selbstbedienungsdienst für Feinabstimmungen von OpenAI wird schrittweise eingestellt: Seit dem 7. Mai 2026 können Organisationen, die noch nie eine Feinabstimmung durchgeführt haben, keine Jobs mehr erstellen; seit dem 2. Juli müssen Sie ein feinabgestimmtes Modell in den letzten 60 Tagen 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 priorisieren Sie Prompt Engineering, RAG und Evaluierungen.
Vom Entwicklungsumfeld zur Produktion
Ihr feinabgestimmtes Modell wurde evaluiert und genehmigt. Es ist Zeit, es in die Produktion zu bringen. Diese Lektion behandelt Best Practices für eine zuverlässige, sichere und wartbare Bereitstellung – alles, was ein Modell auf Ihrem Laptop von einem Service unterscheidet, auf den Ihre Nutzer kontinuierlich zugreifen können, ohne dass Sie im Bereitschaftsdienst stehen.
Beginnen wir mit den Grundlagen: Ein feinabgestimmtes Modell funktioniert exakt wie jedes andere OpenAI-Modell. Der einzige Unterschied ist der Modellname, der zu einem langen Identifier wird, der Ihre Organisation, Ihren Suffix und eine Job-ID enthält. Keine zusätzlichen Parameter, keine speziellen Endpunkte.
from openai import OpenAI
client = OpenAI()
# Das feinabgestimmte Modell hat einen eindeutigen Identifier
MODELE_PRODUCTION = "ft:gpt-5.6-luna:votre-org::mon-assistant-v3:abc12345"
response = client.responses.create(
model=MODELE_PRODUCTION,
input="Hello, I have an issue with my order #12345."
)
print(response.output_text)
Zentrale Konfiguration
Dieser Identifier hat eine Besonderheit, die Ihre gesamte Architektur leiten sollte: Er ändert sich bei jeder neuen Version Ihres Modells. Wenn Sie ihn hartcodiert in Ihrer gesamten Anwendung hinterlegen, zwingt dies eine vollständige Neubereitstellung bei jedem kleinsten Update und führt an einem Tag, an dem er an drei verschiedenen Stellen auftaucht, zu einer mühsamen Suche. Legen Sie ihn in eine Umgebungsvariable, wobei das Basismodell als Fallback-Wert dient: Ihre Anwendung startet auch, wenn die Variable nicht gesetzt ist, und vermeidet so einen stillen Servicevorfall am Sonntagabend.
import os
class Config:
"""Zentralisierte Modellkonfiguration."""
# Umgebungsvariable für das Produktionsmodell
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # Fallback auf Basismodell
)
# System-Prompt (kann leer sein, wenn er in die Feinabstimmung integriert wurde)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Generierungsparameter
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Dieselbe Logik gilt für die Aufrufe selbst. Statt client.responses.create-Aufrufe über Ihre gesamte Geschäftslogik zu streuen, kapseln Sie diese in einer einzigen Service-Klasse ein. Sie gewinnen einen zwingenden Engpass, an dem Sie später Logging, Metriken und Fallbacks einbinden können, ohne zwanzig Dateien erneut öffnen zu müssen. Beachten Sie, wie der folgende Service einen optionalen Kontext mit der Frage zusammenstellt und jegliche Ausnahme einfängt, um sie an das Basismodell weiterzuleiten.
from openai import OpenAI
class AssistantService:
"""Service, der Aufrufe an das feinabgestimmte Modell kapselt."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Generiert eine Antwort."""
input_msg = question
if contexte:
input_msg = f"Context: {contexte}\n\nQuestion: {question}"
try:
response = self.client.responses.create(
model=self.model,
reasoning={"effort": "none"}, # temperature erfordert effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Fallback auf Basismodell bei Fehler
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Fallback auf Basismodell."""
print(f"Fallback aktiviert: {erreur}")
response = self.client.responses.create(
model="gpt-5.6-luna",
instructions=Config.SYSTEM_PROMPT,
input=input_msg
)
return response.output_text
Widerstand gegen Vorfälle
Eine degradierte Antwort ist besser als keine Antwort. Wenn Ihr feinabgestimmtes Modell vorübergehend nicht verfügbar ist, ist es besser, auf das Basismodell umzuschalten – mit dem System-Prompt, den Sie genau für diesen Fall aufbewahrt haben –, als dem Nutzer einen Fehler anzuzeigen. Die folgende Funktion verknüpft zwei sich ergänzende Mechanismen: Erstens drei Versuche am primären Modell, mit einer Verzögerung versehen, die bei jedem Misserfolg verdoppelt wird, um eine vorübergehende Überlastung nicht zu verschlimmern; zweitens, nur wenn alles fehlschlägt, ein Aufruf am Fallback-Modell. Halten Sie das fallback-Flag im Ergebnis, da es die einzige nutzbare Spur dafür ist, wie oft dieser Mechanismus tatsächlich ausgelöst wird.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Resilienter Aufruf mit Wiederholung und Fallback."""
for tentative in range(max_retries):
try:
response = client.responses.create(
model=modele_principal,
input=input_msg,
timeout=30
)
return {
"reponse": response.output_text,
"modele_utilise": modele_principal,
"fallback": False
}
except Exception as e:
print(f"Versuch {tentative + 1} fehlgeschlagen: {e}")
if tentative < max_retries - 1:
time.sleep(2 ** tentative) # exponentieller Backoff
# Fallback
try:
response = client.responses.create(
model=modele_fallback,
input=input_msg
)
return {
"reponse": response.output_text,
"modele_utilise": modele_fallback,
"fallback": True
}
except Exception as e:
return {"erreur": str(e), "fallback": True}
Rate Limiting verdient eine gesonderte Behandlung, da es kein Ausfall, sondern eine Regulierung ist: Feinabgestimmte Modelle teilen sich dieselben Rate Limits wie Basismodelle. Ein RateLimitError bittet Sie lediglich, zu warten, und der progressive Wartezeit unten reicht aus, um einen Anstieg zu absorbieren. Wenn der Loop jedoch sein Limit erreicht, ist das Problem nicht mehr vorübergehend, und Sie müssen Ihre Quote überprüfen.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Behandelt Rate Limiting mit progressivem Warten."""
wait = 1
while wait <= max_wait:
try:
return client.responses.create(
model=modele,
input=input_msg
)
except RateLimitError:
print(f"Rate Limit erreicht, warte {wait}s...")
time.sleep(wait)
wait *= 2
raise Exception("Anhaltendes Rate Limit – überprüfen Sie Ihre Quoten")
Protokollieren, was zählt
Strukturiertes Logging verwandelt undurchsichtige Vorfälle in schnelle Diagnosen. Protokollieren Sie für jeden Aufruf das tatsächlich verwendete Modell, das Eingabe- und Ausgabevolumen, die Latenz und das Fallback-Flag. Diese Informationen reichen aus, um die Fragen zu beantworten, die während eines Vorfalls auftreten: Wie lange hat sich die Latenz verschoben? Ist die Kostensteigerung auf den Verkehr oder längere Antworten zurückzuführen? Und wie viele Nutzer wurden tatsächlich vom Basismodell bedient?
import logging
import datetime
logger = logging.getLogger("fine_tuning_prod")
def log_appel(
modele: str,
input_msg: str,
output: str,
latence_ms: float,
fallback: bool
):
"""Strukturiertes Logging für jeden Produktionsaufruf."""
logger.info(
"appel_modele",
extra={
"modele": modele,
"input_tokens": len(input_msg.split()),
"output_tokens": len(output.split()),
"latence_ms": latence_ms,
"fallback": fallback,
"timestamp": datetime.datetime.now().isoformat()
}
)
Auf der Konfigurationsseite gehört alles in eine Umgebungsdatei, die niemals in Ihr Repository aufgenommen werden darf: Sie enthält Ihren API-Schlüssel, und ein veröffentlichter Schlüssel ist ein kompromittierter Schlüssel.
# .env (nicht committen)
OPENAI_API_KEY=sk-...
OPENAI_FT_MODEL=ft:gpt-5.6-luna:org::suffix:abc12345
OPENAI_FT_MODEL_FALLBACK=gpt-5.6-luna
SYSTEM_PROMPT="You are a professional customer support assistant."
MAX_TOKENS=1024
TEMPERATURE=0.7
Vor dem Öffnen der Schleusen
Bevor Sie den Service Ihren Nutzern aussetzen, gehen Sie die Prüfungen in dieser Lektion nacheinander durch. Das Modell muss gegen die Schwelle evaluiert und genehmigt worden sein, die Sie im Voraus definiert haben; sein Name muss in einer Umgebungsvariable leben und nirgendwo hartcodiert sein; ein Fallback-Mechanismus muss vorhanden sein. Diese drei Punkte bedingen alles Weitere, denn ohne sie bringen Sie ein Modell online, dessen gemessene Qualität, exakte Adresse und sein Verhalten bei schlechter API-Antwort unbekannt sind.
Als Nächstes prüfen Sie die Instrumentierung. Logging muss aktiviert sein und mindestens das verwendete Modell, die Latenz und die Tokens protokollieren; Rate Limiting muss gehandhabt werden, nicht erduldet; Warnungen müssen bei Fehlerrate und P95-Latenz konfiguriert sein, sonst spielt Ihr erster unglücklicher Nutzer die Rolle der Sonde. Schließlich muss ein Rollback dokumentiert und testbar sein – ein Rollback, das nie tatsächlich ausgeführt wurde, bleibt eine Absicht und kein Mechanismus.
Kernaussagen
- Verwenden Sie Umgebungsvariablen für den Modellnamen
- Implementieren Sie immer einen Fallback auf das Basismodell
- Protokollieren Sie jeden Aufruf mit dem verwendeten Modell und der Latenz
- Behandeln Sie Rate Limiting mit exponentiellem Backoff
- Testen Sie Ihren Fallback-Mechanismus, bevor Sie bereitstellen