Deploy en finjusteret model
På denne side
Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(API Responses) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Opdatering 2. november 2026 — Tilgængelighed af finjustering. OpenAIs selvbetjente finjustering udfases: Siden 7. maj 2026 kan organisationer, der aldrig har udført finjustering, ikke længere oprette jobs; siden 2. juli skal du have brugt en finjusteret model inden for de sidste 60 dage; og fra 6. januar 2027 vil ingen kunde kunne starte nye jobs. Allerede trænede modeller forbliver brugbare, indtil deres basismodel trækkes tilbage. Dette kursus forbliver nyttigt til at forstå og udnytte en eksisterende model; til nye projekter bør du prioritere prompt engineering, RAG og evalueringer.
Fra udvikling til produktion
Din finjusterede model er evalueret og godkendt. Det er tid til at deploye den til produktion. Denne lektion dækker bedste praksis for en pålidelig, sikker og vedligeholdelsesvenlig deployment – alt det, der adskiller en model, der kører på din bærbar, fra en tjeneste, dine brugere kan ramme kontinuerligt, uden at du skal være på vagt.
Lad os starte med det grundlæggende: En finjusteret model fungerer præcis som enhver anden OpenAI-model. Den eneste forskel er modelnavnet, som bliver en lang identifikator, der inkluderer din organisation, dit suffiks og et job-ID. Ingen ekstra parametre, ingen specielle endpoints.
from openai import OpenAI
client = OpenAI()
# Den finjusterede model har en unik identifikator
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)
Centralisér konfiguration
Denne identifikator har én ejendommelighed, som bør styre hele din arkitektur: Den ændrer sig med hver ny version af din model. Hvis du hardcoder den i hele din applikation, tvinger det en fuld gen-deployment ved den mindste opdatering og en kedelig søgning den dag, den dukker op tre forskellige steder. Placér den i en miljøvariabel med basismodellen som fallback-værdi: Din applikation vil starte, selvom variablen ikke er sat, hvilket undgår en stille tjenesteincident en søndag aften.
import os
class Config:
"""Centraliseret modelkonfiguration."""
# Miljøvariabel for produktionsmodellen
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # fallback til basismodel
)
# System-prompt (kan være tom, hvis integreret i finjustering)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Genereringsparametre
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Den samme logik gælder for selve kaldene. I stedet for at sprede client.responses.create-kald ud over din forretningslogik, skal du kapsle dem ind i en enkelt tjeneste. Du får et obligatorisk kontrolpunkt, hvor du senere kan tilslutte logning, metrikker og fallback uden at genåbne tyve filer. Bemærk, hvordan tjenesten nedenfor sammensætter en valgfri kontekst med spørgsmålet, og hvordan den fanger enhver undtagelse for at omdirigere den til basismodellen.
from openai import OpenAI
class AssistantService:
"""Tjeneste der kapsler kald til den finjusterede model."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Genererer et svar."""
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 kræver effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Fallback til basismodel ved fejl
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Fallback til basismodel."""
print(f"Fallback aktiveret: {erreur}")
response = self.client.responses.create(
model="gpt-5.6-luna",
instructions=Config.SYSTEM_PROMPT,
input=input_msg
)
return response.output_text
Modstå incidenter
Et forringet svar er bedre end intet svar. Hvis din finjusterede model midlertidigt er utilgængelig, er det bedre at skifte til basismodellen – med den system-prompt, du netop har beholdt til dette tilfælde – end at vise en fejl til brugeren. Funktionen nedenfor kæder to komplementære mekanismer sammen: Først tre forsøg på den primære model, adskilt af en forsinkelse, der fordobles ved hver fejl for at undgå at forværre en midlertidig overbelastning; derefter, kun hvis alt fejler, et kald til fallback-modellen. Behold flaget fallback, der returneres i resultatet, da det er det eneste brugbare spor for, hvor ofte denne mekanisme faktisk udløses.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Resilient kald med genforsøg og 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"Forsøg {tentative + 1} mislykkedes: {e}")
if tentative < max_retries - 1:
time.sleep(2 ** tentative) # eksponentiel 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 fortjener separat behandling, fordi det ikke er en nedetid, men en regulering: Finjusterede modeller deler de samme rate limits som basismodeller. En RateLimitError beder dig blot om at vente, og den progressive ventetid nedenfor er nok til at absorbere en top. Hvis løkken når sit loft, er problemet dog ikke længere konjunkturelt, og du skal gennemgå din kvote.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Håndterer rate limiting med progressiv ventetid."""
wait = 1
while wait <= max_wait:
try:
return client.responses.create(
model=modele,
input=input_msg
)
except RateLimitError:
print(f"Rate limit nået, venter {wait}s...")
time.sleep(wait)
wait *= 2
raise Exception("Vedvarende rate limit – tjek dine kvoter")
Log dét, der betyder noget
Struktureret logning gør uigennemsigtige incidenter til hurtige diagnoser. For hvert kald skal du registrere den faktisk brugte model, input- og output-volumen, latenstid og fallback-flagget. Disse oplysninger er nok til at besvare de spørgsmål, der opstår under en incident: Hvor længe har latenstiden drevet, skyldes omkostningsstigningen trafik eller længere svar, og hvor mange brugere blev faktisk betjent af basismodellen.
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
):
"""Struktureret log for hvert produktionskald."""
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()
}
)
På konfigurationssiden skal alt ind i en miljøfil, som aldrig må ende i dit repository: Den indeholder din API-nøgle, og en offentliggjort nøgle er en kompromitteret nøgle.
# .env (må ikke committe)
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
Før du åbner sluserne
Før du udsætter tjenesten for dine brugere, skal du gennemgå tjeklisten i denne lektion punkt for punkt. Modellen skal være evalueret og godkendt i forhold til den tærskel, du definerede på forhånd; dens navn skal leve i en miljøvariabel og ingen steder hardcodet; en fallback-mekanisme skal være på plads. Disse tre punkter betinger alt andet, for uden dem sætter du en model online, hvis målte kvalitet, præcise adresse og adfærd, når API’et svarer dårligt, er ukendt.
Tjek derefter instrumenteringen. Logning skal være aktiveret og registrere som minimum den brugte model, latenstid og tokens; rate limiting skal håndteres frem for at blive lidt under; alarmer skal konfigureres på fejlrate og P95-latenstid, ellers vil din første utilfredse bruger spille rollen som sonden. Endelig skal rollback være dokumenteret og testbar – en rollback, der aldrig faktisk er udført, forbliver en intention, ikke en mekanisme.
Vigtige pointer
- Brug miljøvariabler til modelnavnet
- Implementér altid en fallback til basismodellen
- Log hvert kald med den brugte model og latenstid
- Håndtér rate limiting med eksponentiel backoff
- Test din fallback-mekanisme før deployment