Distribuera en finjusterad modell
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAIs dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(API Responses) ellerreasoning_effort="none"(Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.
Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningstjänst för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig tidigare utfört finjustering inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell inom de senaste 60 dagarna; och från och med 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.
Från utveckling till produktion
Din finjusterade modell är utvärderad och godkänd. Det är dags att distribuera den till produktion. Denna lektion täcker bästa praxis för en pålitlig, säker och underhållsbar distribution – allt som skiljer en modell som körs på din bärbara dator från en tjänst som dina användare kan nå kontinuerligt utan att du behöver vara i beredskap.
Låt oss börja med grunderna: en finjusterad modell fungerar exakt som vilken annan OpenAI-modell som helst. Den enda skillnaden är modellnamnet, som blir en lång identifierare som inkluderar din organisation, ditt suffix och ett jobb-ID. Inga extra parametrar, inga speciella slutpunkter.
from openai import OpenAI
client = OpenAI()
# Den finjusterade modellen har en unik identifierare
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)
Centralisera konfigurationen
Denna identifierare har en egenhet som bör styra hela din arkitektur: den ändras vid varje ny version av din modell. Att hårdkoda den i hela din applikation tvingar fram en fullständig ominstallering vid den minsta uppdatering, och leder till en tröttsam jakt den dag den dyker upp på tre olika ställen. Lägg den i en miljövariabel, med basmodellen som reservvärde: din applikation kommer att starta även om variabeln inte är satt, vilket undviker en tyst tjänstestörning en söndagsnatt.
import os
class Config:
"""Centraliserad modellkonfiguration."""
# Miljövariabel för produktionsmodellen
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # reserv till basmodell
)
# Systemprompt (kan vara tom om integrerad i finjusteringen)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Genereringsparametrar
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Samma logik gäller för själva anropen. Istället för att sprida ut client.responses.create-anrop i hela din affärslogik, kapsla in dem i en enda tjänst. Du får en obligatorisk flaskhals där du senare kan koppla in loggning, mätvärden och reservlösningar utan att behöva öppna tjugo filer igen. Lägg märke till hur tjänsten nedan komponerar en valfri kontext med frågan, och hur den fångar alla undantag för att omdirigera dem till basmodellen.
from openai import OpenAI
class AssistantService:
"""Tjänst som kapslar in anrop till den finjusterade modellen."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Genererar ett 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:
# Reserv till basmodell vid fel
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Reserv till basmodell."""
print(f"Fallback activated: {erreur}")
response = self.client.responses.create(
model="gpt-5.6-luna",
instructions=Config.SYSTEM_PROMPT,
input=input_msg
)
return response.output_text
Motstå incidenter
Ett försämrat svar är bättre än inget svar alls. Om din finjusterade modell tillfälligt inte är tillgänglig är det bättre att växla till basmodellen – med den systemprompt du behållit just för detta fall – än att visa ett felmeddelande för användaren. Funktionen nedan kedjar två komplementära mekanismer: först tre försök på den primära modellen, med ett dröjsmål som fördubblas vid varje misslyckande för att inte förvärra en tillfällig överbelastning; sedan, endast om allt misslyckas, ett anrop till reservmodellen. Behåll flaggan fallback som returneras i resultatet, eftersom det är det enda användbara spåret för hur ofta denna mekanism faktiskt utlöses.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Motståndskraftigt anrop med återförsök och reserv."""
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"Attempt {tentative + 1} failed: {e}")
if tentative < max_retries - 1:
time.sleep(2 ** tentative) # exponentiell backoff
# Reserv
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}
Begränsning av hastighet (rate limiting) förtjänar en separat behandling eftersom det inte är ett driftstopp utan en reglering: finjusterade modeller delar samma hastighetsbegränsningar som basmodellerna. Ett RateLimitError ber dig helt enkelt att vänta, och den progressiva väntan nedan räcker för att absorbera en topp. Om loopen når sitt tak är problemet dock inte längre tillfälligt och du behöver se över din kvot.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Hanterar hastighetsbegränsning med progressiv väntan."""
wait = 1
while wait <= max_wait:
try:
return client.responses.create(
model=modele,
input=input_msg
)
except RateLimitError:
print(f"Rate limit reached, waiting {wait}s...")
time.sleep(wait)
wait *= 2
raise Exception("Persistent rate limit — check your quotas")
Logga det som betyder något
Strukturerad loggning gör oklara incidenter till snabba diagnoser. För varje anrop, registrera vilken modell som faktiskt användes, volymen på in- och utdata, latens och reservflaggan. Denna information räcker för att svara på de frågor som uppstår under en incident: hur länge har latensen drivit iväg, beror kostnadsökningen på trafik eller längre svar, och hur många användare fick egentligen service av basmodellen.
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
):
"""Strukturerad logg för varje produktionsanrop."""
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()
}
)
När det gäller konfigurationen hamnar allt i en miljöfil som aldrig får hamna i ditt arkiv: den innehåller din API-nyckel, och en publicerad nyckel är en komprometterad nyckel.
# .env (commit:a inte)
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
Innan du öppnar slussarna
Innan du exponerar tjänsten för dina användare, gå igenom kontrollerna i denna lektion en efter en. Modellen måste ha utvärderats och godkänts mot den tröskel du definierat i förväg; dess namn måste finnas i en miljövariabel och nowhere hårdkodad; en reservmekanism måste finnas på plats. Dessa tre punkter är avgörande för allt annat, för utan dem lägger du ut en modell online vars uppmätta kvalitet, exakta adress och beteende när API:t svarar dåligt är okända.
Kontrollera därefter instrumenteringen. Loggning måste vara aktiverad och registrera åtminstone vilken modell som användes, latens och tokens; hastighetsbegränsning måste hanteras snarare än lidas; aviseringar måste konfigureras för felprocent och P95-latens, annars kommer din första missnöjda användare att få spela rollen som sond. Slutligen måste rollback vara dokumenterad och testbar – en rollback som aldrig faktiskt utförts förblir en intention, inte en mekanism.
Viktiga punkter
- Använd miljövariabler för modellnamnet
- Implementera alltid en reservlösning till basmodellen
- Logga varje anrop med använd modell och latens
- Hantera hastighetsbegränsning med exponentiell backoff
- Testa din reservmekanism innan distribution