Разполагане на фино настроен модел
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите
temperatureиtop_pсе приемат само при усилие за разсъждение (reasoning effort) от типаnone, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Следователно заявките, които задават тези параметри, трябва изрично да посочватreasoning={"effort": "none"}(за API Responses) илиreasoning_effort="none"(за Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.
Актуализация от 2 ноември 2026 г. — Наличност на фино настройване. Услугата за самостоятелно фино настройване на OpenAI се прекратява постепенно: от 7 май 2026 г. организациите, които никога не са извършвали фино настройване, вече не могат да създават задачи; от 2 юли е необходимо да сте използвали фино настроен модел през последните 60 дни; а считано от 6 януари 2027 г. никой клиент няма да може да стартира нови задачи. Вече обучените модели остават usable до оттеглянето на базовия им модел. Този курс остава полезен за разбиране и използване на съществуващ модел; за нови проекти дайте приоритет на инженерството на подкани (prompt engineering), RAG и оценяването.
От разработка към продукция
Вашият фино настроен модел е оценен и одобрен. Време е да го разположите в продукция. Този урок обхваща най-добрите практики за надеждно, сигурно и поддържаемо разполагане – всичко онова, което отличава модел, работещ на лаптопа Ви, от услуга, до която потребителите Ви имат достъп непрекъснато, без да се налага да сте на дежурство.
Нека започнем с основите: фино настройкият модел работи точно като всеки друг модел на OpenAI. Единствената разлика е името на модела, което се превръща в дълъг идентификатор, включващ Вашата организация, Вашия суфикс и ID на задачата. Няма допълнителни параметри, няма специални крайни точки (endpoints).
from openai import OpenAI
client = OpenAI()
# Фино настройкият модел има уникален идентификатор
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)
Централизиране на конфигурацията
Този идентификатор има една особеност, която трябва да управлява цялата Ви архитектура: той се променя с всяка нова версия на модела. Твърдото кодиране (hard-coding) на идентификатора във Вашето приложение налага пълно повторно разполагане за най-малката актуализация и досадно търсене в деня, в който се появи на три различни места. Поставете го в променлива на средата, като използвате базовия модел като резервна стойност: Вашето приложение ще стартира дори ако променливата не е зададена, избягвайки тих инцидент със servicе в неделя вечер.
import os
class Config:
"""Централизирана конфигурация на модела."""
# Променлива на средата за производствения модел
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # резервна стойност към базовия модел
)
# Системна подкана (може да е празна, ако е интегрирана във фино настройването)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Параметри за генериране
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
Същата логика важи и за самите извиквания. Вместо да разпръсквате извикванията на client.responses.create във Вашата бизнес логика, ги обгърнете в един единствен сервис. Така печелите задължителна точка на контрол, където по-късно можете да включите записване в дневници (logging), метрики и механизми за отказоустойчивост, без да се налага да отваряте отново двадесет файла. Обърнете внимание как сервисът по-долу съставя незадължителен контекст с въпроса и как прихваща всяко изключение, за да го пренасочи към базовия модел.
from openai import OpenAI
class AssistantService:
"""Сервис, обгръщащ извикванията към фино настройкия модел."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Генерира отговор."""
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 изисква effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Преминаване към базовия модел при грешка
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Преминаване към базовия модел."""
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
Устойчивост при инциденти
Един влошен отговор е по-добър от липсата на такъв. Ако Вашият фино настроен модел е временно недостъпен, е по-добре да превключите към базовия модел – със системната подкана, която сте запазили точно за този случай – отколкото да показвате грешка на потребителя. Следващата функция свързва два допълващи се механизма: първо, три опита на основния модел, разделени от забавяне, което се удвоява при всеки неуспех, за да не се влошава временно претоварване; след това, само ако всичко се провали, извикване на резервния модел. Запазете флага fallback, върнат в резултата, тъй като той е единствената използваема следа за това колко често този механизъм действително се задейства.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Устойчиво извикване с повторни опити и резервен механизъм."""
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) # експоненциално забавяне
# Резервен механизъм
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) заслужава отделно третиране, защото не представлява прекъсване, а регулация: фино настроените модели споделят същите лимити на скоростта като базовите модели. Грешка RateLimitError просто Ви моли да изчакате и прогресивното изчакване по-долу е достатъчно, за да поеме скок в трафика. Ако обаче цикълът достигне тавана си, проблемът вече не е ситуационен и трябва да прегледате Вашите квоти.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Обработва ограничаването на скоростта с прогресивно изчакване."""
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")
Записвайте важното
Структурираното записване в дневници превръща неясните инциденти в бърза диагностика. За всяко извикване записвайте действително използвания модел, обема на входа и изхода, латентността и флага за резервен механизъм. Тази информация е достатъчна, за да отговорите на въпросите, възникващи по време на инцидент: от колко време латентността се отклонява, дали увеличението на разходите се дължи на трафик или на по-дълги отговори и колко потребители всъщност са били обслужени от базовия модел.
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
):
"""Структуриран запис в дневника за всяко производствено извикване."""
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()
}
)
От гледна точка на конфигурацията, всичко отива във файл с променливи на средата, който никога не трябва да попада във Вашето хранилище (repository): той съдържа Вашия API ключ, а публикуван ключ е компрометиран ключ.
# .env (не комитвайте)
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
Преди да отворите шлюзовете
Преди да изложите услугата на Вашите потребители, преминете през проверките в този урок една по една. Моделът трябва да е бил оценен и одобрен спрямо прага, който сте определили предварително; името му трябва да се намира в променлива на средата и никъде да не е твърдо кодирано; трябва да има внедрен механизъм за отказоустойчивост. Тези три точки обуславят всичко останало, защото без тях пускате онлайн модел, чието измерено качество, точен адрес и поведение при лош отговор от API са неизвестни.
След това проверете инструментариума. Записването в дневници трябва да е активирано и да регистрира поне използвания модел, латентността и токените; ограничаването на скоростта трябва да се управлява, а не просто да се търпи; предупрежденията трябва да са конфигурирани за честота на грешките и P95 латентност, в противен случай първият Ви недоволен потребител ще играе ролята на сонда. Накрая, връщането към предишна версия (rollback) трябва да бъде документирано и тестваемо – едно връщане назад, което никога не е изпълнявано реално, остава намерение, а не механизъм.
Ключови изводи
- Използвайте променливи на средата за името на модела
- Винаги внедрявайте резервен механизъм към базовия модел
- Записвайте в дневник всяко извикване с използвания модел и латентност
- Обработвайте ограничаването на скоростта с експоненциално забавяне
- Тествайте механизма си за отказоустойчивост преди разполагане