Wdrażanie dostrojonego modelu
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry
temperatureitop_psą akceptowane tylko przy wysiłku rozumowania (reasoning effort) ustawionym nanone, podczas gdy modele GPT-5.6 domyślnie rozumują z wysiłkiemmedium. Wywołania ustawiające te parametry muszą zatem określaćreasoning={"effort": "none"}(API Responses) lubreasoning_effort="none"(Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.
Aktualizacja z 2 listopada 2026 — Dostępność dostrajania. Usługa samodzielnego dostrajania OpenAI jest wycofywana: od 7 maja 2026 organizacje, które nigdy wcześniej nie przeprowadzały dostrajania, nie mogą już tworzyć zadań; od 2 lipca konieczne jest użycie dostrojonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027, żaden klient nie będzie mógł uruchomić nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs pozostaje przydatny do zrozumienia i wykorzystania istniejącego modelu; w przypadku nowych projektów priorytetowo traktuj inżynierię promptów, RAG oraz ewaluacje.
Od rozwoju do produkcji
Twój dostrojony model został poddany ewaluacji i zatwierdzony. Czas wdrożyć go do produkcji. Ta lekcja omawia najlepsze praktyki dotyczące niezawodnego, bezpiecznego i łatwego w utrzymaniu wdrożenia – wszystko to, co odróżnia model działający na Twoim laptopie od usługi, z której użytkownicy mogą korzystać ciągle, bez konieczności bycia w gotowości (on-call).
Zacznijmy od podstaw: dostrojony model działa dokładnie tak samo jak każdy inny model OpenAI. Jedyną różnicą jest nazwa modelu, która staje się długim identyfikatorem zawierającym Twoją organizację, przyrostek (suffix) oraz ID zadania. Żadnych dodatkowych parametrów, żadnych specjalnych punktów końcowych.
from openai import OpenAI
client = OpenAI()
# Dostrojony model ma unikalny identyfikator
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)
Centralizacja konfiguracji
Ten identyfikator ma jedną cechę, która powinna rządzić całą Twoją architekturą: zmienia się przy każdej nowej wersji modelu. Sztywne zakodowanie go (hard-coding) w całej aplikacji wymusza pełne ponowne wdrożenie przy najmniejszej aktualizacji i żmudne poszukiwania w dniu, w którym pojawi się w trzech różnych miejscach. Umieść go w zmiennej środowiskowej, z modelem bazowym jako wartością zapasową (fallback): Twoja aplikacja uruchomi się nawet, jeśli zmienna nie zostanie ustawiona, unikając cichej awarii usługi w niedzielny wieczór.
import os
class Config:
"""Scentralizowana konfiguracja modelu."""
# Zmienna środowiskowa dla modelu produkcyjnego
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # fallback do modelu bazowego
)
# Prompt systemowy (może być pusty, jeśli zintegrowany z dostrajaniem)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Parametry generowania
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Ta sama logika dotyczy samych wywołań. Zamiast rozrzucać wywołania client.responses.create po całej logice biznesowej, zamknij je w pojedynczej usłudze. Zyskujesz obowiązkowy punkt kontrolny, w którym później możesz podpiąć logowanie, metryki i mechanizmy zapasowe, nie otwierając dwudziestu plików. Zauważ, jak poniższa usługa komponuje opcjonalny kontekst z pytaniem i jak przechwytuje dowolny wyjątek, aby przekierować go do modelu bazowego.
from openai import OpenAI
class AssistantService:
"""Usługa encapsulująca wywołania do dostrojonego modelu."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Generuje odpowiedź."""
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 wymaga wysiłku none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Fallback do modelu bazowego w przypadku błędu
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Fallback do modelu bazowego."""
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
Odporność na incydenty
Degradacja odpowiedzi jest lepsza niż brak odpowiedzi. Jeśli Twój dostrojony model jest tymczasowo niedostępny, lepiej przełączyć się na model bazowy – z promptem systemowym, który zachowałeś właśnie na ten wypadek – niż wyświetlać użytkownikowi błąd. Poniższa funkcja łączy dwa komplementarne mechanizmy: najpierw trzy próby na modelu głównym, oddzielone opóźnieniem, które podwaja się przy każdej niepowodzeniu, aby nie pogarszać tymczasowego przeciążenia; następnie, tylko jeśli wszystko zawiedzie, wywołanie modelu zapasowego. Zachowaj flagę fallback zwróconą w wyniku, ponieważ jest to jedyny użyteczny ślad tego, jak często ten mechanizm faktycznie się uruchamia.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Odporność wywołania z ponawianiem i fallbackiem."""
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) # wykładnicze opóźnienie (exponential 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}
Limitowanie częstotliwości (rate limiting) zasługuje na osobne potraktowanie, ponieważ nie jest to awaria, lecz regulacja: modele dostrojone dzielą te same limity częstotliwości co modele bazowe. Błąd RateLimitError po prostu prosi o oczekiwanie, a poniższe progresywne czekanie wystarczy, aby złagodzić skok obciążenia. Jeśli jednak pętla osiągnie swój sufit, problem nie ma już charakteru doraźnego i musisz przejrzeć swoje kwoty.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Obsługuje limitowanie częstotliwości z progresywnym oczekiwaniem."""
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, co istotne
Strukturalne logowanie zamienia nieprzejrzyste incydenty w szybką diagnostykę. Dla każdego wywołania zapisz faktycznie użyty model, wolumen wejścia i wyjścia, opóźnienie (latencję) oraz flagę fallback. Te informacje wystarczą, aby odpowiedzieć na pytania pojawiające się podczas incydentu: jak długo opóźnienie się pogarsza, czy wzrost kosztów wynika z ruchu, czy z dłuższych odpowiedzi, i ilu użytkowników zostało faktycznie obsłużonych przez model bazowy.
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
):
"""Strukturalny log dla każdego wywołania produkcyjnego."""
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()
}
)
Jeśli chodzi o konfigurację, wszystko trafia do pliku środowiskowego, który nigdy nie powinien trafić do Twojego repozytorium: zawiera on Twój klucz API, a opublikowany klucz to klucz skompromitowany.
# .env (nie commituj)
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
Przed otwarciem śluz
Zanim udostępnisz usługę swoim użytkownikom, przejdź punkt po punkcie przez kontrole z tej lekcji. Model musiał zostać poddany ewaluacji i zatwierdzony względem progu zdefiniowanego wcześniej; jego nazwa musi znajdować się w zmiennej środowiskowej i nigdzie nie być sztywno zakodowana; mechanizm fallback musi być wdrożony. Te trzy punkty warunkują wszystko inne, ponieważ bez nich wprowadzasz do sieci model, którego mierzona jakość, dokładny adres i zachowanie w przypadku słabej odpowiedzi API są nieznane.
Następnie sprawdź instrumentację. Logowanie musi być włączone i rejestrować co najmniej użyty model, opóźnienie i tokeny; limitowanie częstotliwości musi być obsługiwane, a nie tylko tolerowane; alerty muszą być skonfigurowane na wskaźnik błędów i latencję P95, w przeciwnym razie Twój pierwszy niezadowolony użytkownik przejmie rolę sondy. Na koniec wycofanie (rollback) musi być udokumentowane i możliwe do przetestowania – wycofanie, które nigdy nie zostało faktycznie wykonane, pozostaje jedynie intencją, a nie mechanizmem.
Kluczowe wnioski
- Używaj zmiennych środowiskowych dla nazwy modelu
- Zawsze implementuj fallback do modelu bazowego
- Loguj każde wywołanie z użytym modelem i opóźnieniem
- Obsługuj limitowanie częstotliwości za pomocą wykładniczego opóźnienia (exponential backoff)
- Przetestuj swój mechanizm fallback przed wdrożeniem