Uvedba fino uglašenega modela
Na tej strani
Posodobitev lekcije 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra
temperatureintop_psta sprejeta le pri naporu razmišljanja (reasoning effort) vrednostinone, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določitireasoning={"effort": "none"}(API Responses) alireasoning_effort="none"(Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.
Posodobitev 2. novembra 2026 — Razpoložljivost fino uglaševanja. Samostojno fino uglaševanje podjetja OpenAI se postopno ukinja: od 7. maja 2026 organizacije, ki še nikoli niso izvedle fino uglaševanja, ne morejo več ustvarjati opravil; od 2. julija morate biti uporabili fino uglašen model v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler njihov osnovni model ni upokojen. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječega modela; za nove projekte dajte prednost inženiringu pozivov, RAG in evalvacijam.
Od razvoja do produkcije
Vaš fino uglašeni model je ovrednoten in odobren. Čas je, da ga uvedete v produkcijo. Ta lekcija pokriva najboljše prakse za zanesljivo, varno in vzdrževano uvedbo – vse tisto, kar loči model, ki teče na vašem prenosniku, od storitve, ki jo vaši uporabniki lahko neprekinjeno uporabljajo, ne da bi bili vi dežurni.
Začnimo z osnovami: fino uglašeni model deluje popolnoma enako kot kateri koli drug model OpenAI. Edina razlika je ime modela, ki postane dolg identifikator, vključno z vašo organizacijo, vašo pripono in ID-jem opravila. Ni dodatnih parametrov, ni posebnih končnih točk.
from openai import OpenAI
client = OpenAI()
# Fino uglašeni model ima edinstven 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)
Centraliziraj konfiguracijo
Ta identifikator ima eno posebnost, ki bi morala voditi celotno vašo arhitekturo: spremeni se z vsako novo različico vašega modela. Trdo kodiranje tega identifikatorja po celotni aplikaciji prisili popolno ponovno uvedbo za vsako najmanjšo posodobitev in povzroči dolgočasno iskanje, ko se ta pojavi na treh različnih mestih. Postavite ga v okoljsko spremenljivko, z osnovnim modelom kot nadomestno vrednostjo: vaša aplikacija se bo zagnala, tudi če spremenljivka ni nastavljena, s čimer se izognete tihi incidentni zaustavitvi storitve nedeljo zvečer.
import os
class Config:
"""Centralizirana konfiguracija modela."""
# Okoljska spremenljivka za produkcijski model
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # nadomestni osnovni model
)
# Sistemski poziv (lahko je prazen, če je integriran v fino uglaševanje)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Parametri generiranja
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Enaka logika velja za same klice. Namesto da bi razpršili klice client.responses.create po svoji poslovni logiki, jih zaprite v eno samo storitev. S tem pridobite obvezno ozko grlo, kamor lahko kasneje priklopite beleženje, metrike in nadomestne mehanizme, ne da bi morali znova odpirati dvajset datotek. Opazite, kako spodnja storitev združuje poljubni kontekst z vprašanjem in kako ujame vsako izjemo, da jo preusmeri na osnovni model.
from openai import OpenAI
class AssistantService:
"""Storitev, ki encapsulira klice fino uglašenega modela."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Generira odgovor."""
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"}, # temperatura zahteva napor none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Nadomestni osnovni model ob napaki
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Preklop na osnovni model."""
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
Upri se incidentom
Poslabšan odgovor je boljši od nobenega odgovora. Če je vaš fino uglašeni model začasno nedostopen, je bolje preklopiti na osnovni model – s sistemskim pozivom, ki ste ga ohranili prav za ta primer – kot da uporabniku prikažete napako. Naslednja funkcija veriži dva komplementarna mehanizma: najprej tri poskuse na primarnem modelu, razmaknjene z zamikom, ki se z vsako napako podvoji, da se izogne poslabšanju začasne preobremenitve; nato, le če vse odpove, klic nadomestnega modela. Ohranite zastavico fallback, vrnjeno v rezultatu, saj je edina uporabna sled o tem, kako pogosto se ta mehanizem dejansko sproži.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Odporne klic z ponovitvijo in nadomestnim modelom."""
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) # eksponentno odlašanje
# Nadomestni model
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}
Omejevanje hitrosti (rate limiting) zasluži ločeno obravnavo, saj ne gre za izpad, temveč za regulacijo: fino uglašeni modeli si delijo enake omejitve hitrosti kot osnovni modeli. Napaka RateLimitError preprosto zahteva, da počakate, in spodnje progresivno čakanje je dovolj za absorpcijo skoka prometa. Če pa zanka doseže svoj strop, težava ni več trenutne narave in morate pregledati svojo kvoto.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Obdelava omejevanja hitrosti s progresivnim čakanjem."""
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")
Beleži tisto, kar je pomembno
Strukturirano beleženje pretvori neprozorne incidente v hitro diagnostiko. Za vsak klic zabeležite dejansko uporabljeni model, volumen vhoda in izhoda, zakasnitev in zastavico za nadomestni model. Te informacije zadostujejo za odgovore na vprašanja, ki se pojavijo med incidentom: kako dolgo zakasnitev že narašča, ali je povečanje stroškov posledica prometa ali daljših odgovorov in koliko uporabnikov je dejansko postregel osnovni model.
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
):
"""Strukturirano beleženje za vsak produkcijski klic."""
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()
}
)
Kar zadeva konfiguracijo, vse gre v okoljsko datoteko, ki nikoli ne sme vstopiti v vaše skladišče: vsebuje vaš API ključ, objavljen ključ pa pomeni ogrožen ključ.
# .env (ne commitaj)
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
Preden odprete zapornice
Preden storitev izpostavite svojim uporabnikom, po vrsti opravite preverjanja iz te lekcije. Model mora biti ovrednoten in odobren glede na prag, ki ste ga vnaprej določili; njegovo ime mora živeti v okoljski spremenljivki in nikjer trdo kodirano; mehanizem za nadomestni model mora biti vzpostavljen. Te tri točke pogojujejo vse ostalo, saj brez njih v splet postavljate model, katerega izmerjena kakovost, točen naslov in obnašanje, ko API slabo odgovarja, so neznani.
Nato preverite instrumentacijo. Beleženje mora biti omogočeno in zapisovati vsaj uporabljeni model, zakasnitev in žetone; omejevanje hitrosti mora biti obravnavano, ne pa trpljeno; opozorila morajo biti konfigurirana glede na stopnjo napak in zakasnitev P95, sicer bo vaš prvi nezadovoljni uporabnik odigral vlogo sonde. Končno, povratni korak (rollback) mora biti dokumentiran in preizkusljiv – povratni korak, ki nikoli ni bil dejansko izveden, ostane le namen, ne mehanizem.
Ključne ugotovitve
- Za ime modela uporabite okoljske spremenljivke
- Vedno implementirajte preklop na osnovni model
- Beležite vsak klic z uporabljenim modelom in zakasnitvijo
- Obdelajte omejevanje hitrosti z eksponentnim odlašanjem
- Pred uvedbo preizkusite svoj mehanizem za preklop