Премини към основното съдържание
Български— Изберете език
Меню

Разполагане на фино настроен модел

Урок 14 от 16 Обновен 3 ноември 2026 г. Напреднало
На тази страница
  1. От разработка към продукция
  2. Централизиране на конфигурацията
  3. Устойчивост при инциденти
  4. Записвайте важното
  5. Преди да отворите шлюзовете
  6. Ключови изводи

Урокът е актуализиран на 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) трябва да бъде документирано и тестваемо – едно връщане назад, което никога не е изпълнявано реално, остава намерение, а не механизъм.

Ключови изводи

  • Използвайте променливи на средата за името на модела
  • Винаги внедрявайте резервен механизъм към базовия модел
  • Записвайте в дневник всяко извикване с използвания модел и латентност
  • Обработвайте ограничаването на скоростта с експоненциално забавяне
  • Тествайте механизма си за отказоустойчивост преди разполагане