Een fine-getuned model implementeren
Op deze pagina
Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(API Responses) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Update 2 november 2026 — Beschikbaarheid fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd uitgefaseerd: sinds 7 mei 2026 kunnen organisaties die nog nooit fine-tuning hebben uitgevoerd geen taken meer maken; sinds 2 juli moet u binnen de laatste 60 dagen een fine-getuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.
Van ontwikkeling naar productie
Uw fine-getuned model is geëvalueerd en goedgekeurd. Het is tijd om het in productie te nemen. Deze les behandelt best practices voor een betrouwbare, veilige en onderhoudbare implementatie—alles wat het verschil maakt tussen een model dat op uw laptop draait en een service die uw gebruikers continu kunnen aanspreken zonder dat u constant beschikbaar hoeft te zijn.
Laten we beginnen met de basis: een fine-getuned model werkt precies zoals elk ander OpenAI-model. Het enige verschil is de modelnaam, die een lange identifier wordt met uw organisatie, uw achtervoegsel en een taak-ID. Geen extra parameters, geen speciale endpoints.
from openai import OpenAI
client = OpenAI()
# Het fine-getuned model heeft een unieke 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)
Centraliseer configuratie
Deze identifier heeft één eigenaardigheid die uw hele architectuur moet sturen: deze verandert bij elke nieuwe versie van uw model. Als u deze hard-codeert in uw hele applicatie, forceert u een volledige herimplementatie voor de kleinste update, en een vervelende zoektocht op de dag dat deze op drie verschillende plekken verschijnt. Zet het in een omgevingsvariabele, met het basismodel als fallback-waarde: uw applicatie start zelfs als de variabele niet is ingesteld, waardoor een stille service-incidents op een zondagavond wordt voorkomen.
import os
class Config:
"""Gecentraliseerde modelconfiguratie."""
# Omgevingsvariabele voor het productiemodel
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # fallback naar basismodel
)
# Systeemprompt (kan leeg zijn als geïntegreerd in fine-tuning)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Generatieparameters
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Dezelfde logica geldt voor de aanroepen zelf. In plaats van client.responses.create-aanroepen te verspreiden door uw bedrijfslogica, kapselt u ze in in één enkele service. U wint een verplicht knelpunt waar u later logging, metrics en fallback aan kunt koppelen zonder twintig bestanden opnieuw te openen. Merk op hoe de onderstaande service een optionele context samenstelt met de vraag, en hoe deze elke uitzondering opvangt om deze door te sturen naar het basismodel.
from openai import OpenAI
class AssistantService:
"""Service die aanroepen naar het fine-getuned model kapselt."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Genereert een antwoord."""
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 vereist effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Fallback naar basismodel bij fout
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Fallback naar basismodel."""
print(f"Fallback geactiveerd: {erreur}")
response = self.client.responses.create(
model="gpt-5.6-luna",
instructions=Config.SYSTEM_PROMPT,
input=input_msg
)
return response.output_text
Weersta incidenten
Een gedegradeerd antwoord is beter dan geen antwoord. Als uw fine-getuned model tijdelijk niet beschikbaar is, is het beter om over te schakelen op het basismodel—met de systeemprompt die u precies voor dit geval hebt bewaard—dan om een fout aan de gebruiker te tonen. De volgende functie koppelt twee complementaire mechanismen: eerst drie pogingen op het primaire model, met tussenpozen die bij elke mislukking verdubbelen om een tijdelijke overbelasting niet te verergeren; daarna, alleen als alles faalt, een aanroep naar het fallback-model. Houd de fallback-vlag die in het resultaat wordt teruggegeven bij, want dit is het enige bruikbare spoor van hoe vaak dit mechanisme daadwerkelijk activeert.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Veerkrachtige aanroep met retry en 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"Poging {tentative + 1} mislukt: {e}")
if tentative < max_retries - 1:
time.sleep(2 ** tentative) # exponentiële 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 een aparte behandeling omdat het geen uitval is maar een regulering: fine-getuned modellen delen dezelfde rate limits als basismodellen. Een RateLimitError vraagt u simpelweg om te wachten, en het progressieve wachten hieronder is voldoende om een piek op te vangen. Als de lus echter zijn plafond bereikt, is het probleem niet langer conjunctureel en moet u uw quota herzien.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Verwerkt rate limiting met progressief wachten."""
wait = 1
while wait <= max_wait:
try:
return client.responses.create(
model=modele,
input=input_msg
)
except RateLimitError:
print(f"Rate limit bereikt, wachten {wait}s...")
time.sleep(wait)
wait *= 2
raise Exception("Aanhoudende rate limit — controleer uw quota")
Log wat belangrijk is
Gestructureerde logging verandert ondoorzichtige incidenten in snelle diagnostics. Leg voor elke aanroep het daadwerkelijk gebruikte model, het volume van input en output, de latentie en de fallback-vlag vast. Deze informatie is voldoende om de vragen te beantwoorden die tijdens een incident rijzen: hoe lang drifft de latentie al, komt de kostenstijging door verkeer of langere antwoorden, en hoeveel gebruikers werden daadwerkelijk bediend door het basismodel.
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
):
"""Gestructureerde log voor elke productieaanroep."""
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()
}
)
Aan de configuratiekant gaat alles naar een omgevingsbestand dat nooit in uw repository mag komen: het bevat uw API-sleutel, en een gepubliceerde sleutel is een gecompromitteerde sleutel.
# .env (niet 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
Voordat u de sluizen opent
Voordat u de service blootstelt aan uw gebruikers, doorloopt u de controles in deze les één voor één. Het model moet zijn geëvalueerd en goedgekeurd tegen de drempel die u vooraf hebt gedefinieerd; de naam moet in een omgevingsvariabele staan en nergens hard-gecodeerd; er moet een fallback-mechanisme aanwezig zijn. Deze drie punten conditioneren al het andere, want zonder ze brengt u een model online waarvan de gemeten kwaliteit, het exacte adres en het gedrag wanneer de API slecht reageert, onbekend zijn.
Controleer vervolgens de instrumentatie. Logging moet zijn ingeschakeld en ten minste het gebruikte model, de latentie en tokens registreren; rate limiting moet worden beheerd in plaats van ondergaan; alerts moeten zijn geconfigureerd op foutpercentage en P95-latentie, anders zal uw eerste ontevreden gebruiker de rol van de sonde spelen. Tot slot moet rollback gedocumenteerd en testbaar zijn—een rollback die nooit daadwerkelijk is uitgevoerd, blijft een intentie, geen mechanisme.
Belangrijkste punten
- Gebruik omgevingsvariabelen voor de modelnaam
- Implementeer altijd een fallback naar het basismodel
- Log elke aanroep met het gebruikte model en de latentie
- Verwerk rate limiting met exponentiële backoff
- Test uw fallback-mechanisme voordat u implementeert