Nasazení doladěného modelu
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovatreasoning={"effort": "none"}(API Responses) neboreasoning_effort="none"(Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.
Aktualizace z 2. listopadu 2026 — Dostupnost doladění. Samoobslužné doladění (fine-tuning) od OpenAI je postupně ukončováno: od 7. května 2026 nemohou organizace, které nikdy neprovedly doladění, vytvářet nové úlohy; od 2. července musíte mít doladěný model použitý během posledních 60 dnů; a počínaje 6. lednem 2027 nebude žádný zákazník schopen spustit nové úlohy. Již natrénované modely zůstávají použitelné až do vyřazení jejich základního modelu. Tento kurz zůstává užitečný pro pochopení a využití stávajícího modelu; u nových projektů upřednostňujte inženýrství promptů, RAG a evaluace.
Od vývoje k produkci
Tvůj doladěný model je vyhodnocen a schválen. Je čas jej nasadit do produkce. Tato lekce pokrývá osvědčené postupy pro spolehlivé, bezpečné a udržovatelné nasazení – vše, co odděluje model běžící na tvém laptopu od služby, kterou mohou tvoji uživatelé nepřetržitě využívat, aniž bys musel být neustále k dispozici.
Začněme základy: doladěný model funguje přesně jako jakýkoli jiný model OpenAI. Jediným rozdílem je název modelu, který se stává dlouhým identifikátorem zahrnujícím tvou organizaci, tvou příponu a ID úlohy. Žádné extra parametry, žádné speciální endpointy.
from openai import OpenAI
client = OpenAI()
# The fine-tuned model has a unique 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)
Centralizace konfigurace
Tento identifikátor má jednu záludnost, která by měla řídit celou tvou architekturu: mění se s každou novou verzí tvého modelu. Pokud jej natvrdo zakóduješ („hard-coding“) napříč celou aplikací, vynutíš si úplné opětovné nasazení při sebemenší aktualizaci a zdlouhavé hledání v den, kdy se objeví na třech různých místech. Umísti jej do proměnné prostředí, přičemž základní model použij jako záložní hodnotu: tvá aplikace se spustí, i když proměnná není nastavena, čímž předejdeš tichému výpadku služby v neděli večer.
import os
class Config:
"""Centralizovaná konfigurace modelu."""
# Proměnná prostředí pro produkční model
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # záloha na základní model
)
# Systémový prompt (může být prázdný, pokud je integrován do doladění)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Parametry generování
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Stejná logika platí i pro samotná volání. Místo rozhazování volání client.responses.create po celé tvé obchodní logice je zapouzdři do jediné služby. Získáš tak povinný kontrolní bod, kam můžeš později připojit logování, metriky a záložní řešení, aniž bys musel znovu otevírat dvacet souborů. Všimni si, jak níže uvedená služba skládá volitelný kontext s otázkou a jak zachytává jakoukoli výjimku, aby ji přesměrovala na základní model.
from openai import OpenAI
class AssistantService:
"""Služba zapouzdřující volání doladěného modelu."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Generuje odpověď."""
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 vyžaduje effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Záloha na základní model při chybě
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Záloha na základní 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
Odolnost vůči incidentům
Degradovaná odpověď je lepší než žádná odpověď. Pokud je tvůj doladěný model dočasně nedostupný, je lepší přepnout se na základní model – se systémovým promptem, který jsi pro tento případ přesně zachoval – než zobrazit uživateli chybu. Následující funkce řetězí dva doplňkové mechanismy: nejprve tři pokusy na primárním modelu, oddělené zpožděním, které se s každým selháním zdvojnásobí, aby se nezhoršilo dočasné přetížení; a teprve pokud vše selže, volání záložního modelu. Zachovej příznak fallback vrácený ve výsledku, protože je to jediná použitelná stopa o tom, jak často se tento mechanismus ve skutečnosti spouští.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Odolné volání s opakováním a zálohou."""
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) # exponenciální backoff
# Záloha
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}
Omezování rychlosti (rate limiting) si zaslouží samostatné zacházení, protože nejde o výpadek, ale o regulaci: doladěné modely sdílejí stejné limity rychlosti jako základní modely. Chyba RateLimitError pouze žádá o čekání a progresivní čekání uvedené níže stačí k absorpci špičky. Pokud však smyčka dosáhne svého stropu, problém již není situační a musíš přezkoumat svou kvótu.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Zpracovává omezování rychlosti s progresivním čekáním."""
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")
Loguj to podstatné
Strukturované logování mění neprůhledné incidenty v rychlou diagnostiku. Pro každé volání zaznamenej skutečně použitý model, objem vstupu a výstupu, latenci a příznak zálohy. Tyto informace stačí k odpovědi na otázky, které vyvstanou během incidentu: jak dlouho se zvyšuje latence, je nárůst nákladů způsoben provozem nebo delšími odpověďmi a kolik uživatelů bylo ve skutečnosti obslouženo základním modelem.
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
):
"""Strukturovaný záznam pro každé produkční volání."""
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()
}
)
Na straně konfigurace vše patří do souboru s proměnnými prostředí, který se nikdy nesmí dostat do tvého repozitáře: obsahuje tvůj API klíč a zveřejněný klíč znamená kompromitovaný klíč.
# .env (do not commit)
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
Před otevřením stavidel
Než službu zpřístupníš svým uživatelům, projdi si bod po bodu kontroly z této lekce. Model musel být vyhodnocen a schválen proti prahu, který jsi předem definoval; jeho název musí žít v proměnné prostředí a nikde není natvrdo zakódován; musí být zaveden mechanismus zálohy. Tyto tři body podmínějí vše ostatní, protože bez nich nasazuješ online model, jehož naměřená kvalita, přesná adresa a chování při špatné odpovědi API jsou neznámé.
Dále zkontroluj instrumentaci. Logování musí být povoleno a zaznamenávat přinejmenším použitý model, latenci a tokeny; omezování rychlosti musí být řešeno, nikoliv trpěno; alerty musí být nakonfigurovány na míru chyb a latenci P95, jinak bude tvůj první nespokojený uživatel hrát roli sondy. Nakonec musí být rollback zdokumentován a testovatelný – rollback, který nebyl nikdy skutečně proveden, zůstává pouze záměrem, nikoliv mechanismem.
Klíčové poznatky
- Používej proměnné prostředí pro název modelu
- Vždy implementuj zálohu na základní model
- Loguj každé volání s použitým modelem a latencí
- Zpracovávej omezování rychlosti pomocí exponenciálního backoffu
- Otestuj svůj záložní mechanismus před nasazením