Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Nasadenie doladeného modelu

Lekcia 14 z 16 Aktualizované 3. novembra 2026 Pokročilý
Na tejto strane
  1. Od vývoja do produkcie
  2. Centralizácia konfigurácie
  3. Odolnosť voči incidentom
  4. Loguj to podstatné
  5. Pred otvorením brán
  6. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (API Responses) alebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Aktualizácia z 2. novembra 2026 — Dostupnosť doladzovania. Služba vlastného doladzovania (self-service fine-tuning) od OpenAI sa postupne ukončuje: od 7. mája 2026 organizácie, ktoré nikdy nevykonali doladzovanie, už nemôžu vytvárať nové úlohy; od 2. júla musíte mať použitý doladený model za posledných 60 dní; a od 6. januára 2027 nebude žiadny zákazník môcť spustiť nové úlohy. Už natrénované modely zostávajú použiteľné až do vyradenia ich základného modelu. Tento kurz zostáva užitočný na pochopenie a využitie existujúceho modelu; pre nové projekty uprednostnite inžinierstvo promptov (prompt engineering), RAG a evaluácie.

Od vývoja do produkcie

Tvoj doladený model je vyhodnotený a schválený. Je čas nasadiť ho do produkcie. Táto lekcia pokrýva osvedčené postupy pre spoľahlivé, bezpečné a udržateľné nasadenie – všetko, čo oddeľuje model bežiaci na tvojom notebooku od služby, ktorú môžu tvoji používatelia nepretržite využívať, aj keď práve nesedíš pri pohotovostnom telefóne.

Začnime základmi: doladený model funguje presne ako ktorýkoľvek iný model OpenAI. Jediný rozdiel je v názve modelu, ktorý sa stáva dlhým identifikátorom obsahujúcim tvoju organizáciu, tvoju príponu a ID úlohy. Žiadne extra parametre, žiadne špeciálne koncové body.

from openai import OpenAI

client = OpenAI()

# Doladený model má jedinečný identifikátor
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)

Centralizácia konfigurácie

Tento identifikátor má jednu zvláštnosť, ktorá by mala riadiť celú tvoju architektúru: mení sa s každou novou verziou tvojho modelu. Ak ho natvrdo zakóduješ („hard-code“) v celej aplikácii, vynútiš si úplné opätovné nasadenie pri každej najmenšej zmene a zdĺhavé hľadanie v deň, keď sa objaví na troch rôznych miestach. Ulož ho do premennej prostredia so základným modelom ako záložnou hodnotou: tvoja aplikácia sa spustí aj vtedy, ak premenná nie je nastavená, čím sa vyhneš tichému výpadku služby v nedeľu večer.

import os

class Config:
    """Centralizovaná konfigurácia modelu."""

    # Premenná prostredia pre produkčný model
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # záložná hodnota na základný model
    )

    # Systémový prompt (môže byť prázdny, ak je integrovaný do doladzovania)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

    # Parametre generovania
    MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
    TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))

Rovnaká logika platí aj pre samotné volania. Namiesto rozhadzovania volaní client.responses.create po celej tvojej business logike ich zapuzdri do jednej služby. Získaš tak povinný kontrolný bod, kde môžeš neskôr pripojiť logovanie, metriky a záložné riešenia bez potreby otvárať dvadsať súborov. Všimni si, ako nižšie uvedená služba skladá voliteľný kontext s otázkou a ako zachytáva akúkoľvek výnimku, aby ju presmerovala na základný model.

from openai import OpenAI

class AssistantService:
    """Služba zapuzdrujúca volania na doladený model."""

    def __init__(self):
        self.client = OpenAI()
        self.model = Config.MODEL_ID

    def repondre(self, question: str, contexte: str = "") -> str:
        """Generuje odpoveď."""
        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áložné riešenie na základný model pri chybe
            return self._fallback(input_msg, str(e))

    def _fallback(self, input_msg: str, erreur: str) -> str:
        """Prepnutie 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

Odolnosť voči incidentom

Degradovaná odpoveď je lepšia ako žiadna odpoveď. Ak je tvoj doladený model dočasne nedostupný, je lepšie prepnúť sa na základný model – so systémovým promptom, ktorý si ponechal presne pre tento prípad – než zobrazovať používateľovi chybu. Nasledujúca funkcia reťazí dva komplementárne mechanizmy: najprv tri pokusy na primárnom modeli, oddelené oneskorením, ktoré sa s každým zlyhaním zdvojnásobí, aby sa nezhoršilo dočasné preťaženie; a až potom, ak všetko zlyhá, volanie záložného modelu. Zachovaj vlajku fallback vrátenú vo výsledku, pretože je to jediná použiteľná stopa o tom, ako často sa tento mechanizmus skutočne spúšťa.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Odolné volanie s opakovanými pokusmi a záložným riešením."""

    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álne oneskorenie

    # Záložné riešenie
    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}

Obmedzenie rýchlosti (rate limiting) si zasluhuje samostatné zaobchádzanie, pretože nejde o výpadok, ale o reguláciu: doladené modely zdieľajú rovnaké limity rýchlosti ako základné modely. Chyba RateLimitError jednoducho žiada, aby si počkal, a progresívne čakanie uvedené nižšie stačí na absorbovanie špičky. Ak však slučka dosiahne svoj strop, problém už nie je dočasný a musíš prehodnotiť svoju kvótu.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Spracováva obmedzenie rýchlosti s progresívnym čakaní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é

Štruktúrované logovanie mení nepriehľadné incidenty na rýchlu diagnostiku. Pre každé volanie zaznamenaj skutočne použitý model, objem vstupu a výstupu, latenciu a vlajku fallback. Tieto informácie stačia na zodpovedanie otázok, ktoré vznikajú počas incidentu: ako dlho sa zvyšuje latencia, je nárast nákladov spôsobený premávkou alebo dlhšími odpoveďami a koľko používateľov bolo skutočne obslúžených základným modelom.

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
):
    """Štruktúrovaný záznam pre každé produkčné volanie."""
    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()
        }
    )

Pokiaľ ide o konfiguráciu, všetko patrí do súboru prostredia, ktorý sa nikdy nesmie dostať do tvojho repozitára: obsahuje tvoj API kľúč a zverejnený kľúč znamená kompromitovaný kľúč.

# .env (neodosielaj do repozitára)
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

Pred otvorením brán

Predtým, než službu vystavíš svojim používateľom, prejdite bod po bode kontrolami z tejto lekcie. Model musel byť vyhodnotený a schválený podľa prahu, ktorý si vopred definoval; jeho názov musí žiť v premennej prostredia a nikde nie je natvrdo zakódovaný; musí byť zavedený mechanizmus záložného riešenia. Tieto tri body podmieňujú všetko ostatné, pretože bez nich uvádzaš online model, ktorého nameraná kvalita, presná adresa a správanie pri zlej odozve API sú neznáme.

Ďalej skontroluj inštrumentáciu. Logovanie musí byť povolené a zaznamenávať aspoň použitý model, latenciu a tokeny; obmedzenie rýchlosti musí byť riešené, nie trpené; alerty musia byť nakonfigurované na mieru chýb a latenciu P95, inak bude tvoj prvý nespokojný používateľ hrať úlohu sondy. Nakoniec, rollback (návrat k predchádzajúcej verzii) musí byť zdokumentovaný a testovateľný – rollback, ktorý sa nikdy skutočne nevykonal, zostáva len zámerom, nie mechanizmom.

Kľúčové poznatky

  • Používaj premenné prostredia pre názov modelu
  • Vždy implementuj záložné riešenie (fallback) na základný model
  • Loguj každé volanie s použitým modelom a latenciou
  • Spracúvaj obmedzenie rýchlosti pomocou exponenciálneho oneskorenia
  • Otestuj svoj mechanizmus fallback pred nasadením