Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Nasazení doladěného modelu

Lekce 14 z 16 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Od vývoje k produkci
  2. Centralizace konfigurace
  3. Odolnost vůči incidentům
  4. Loguj to podstatné
  5. Před otevřením stavidel
  6. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (API Responses) nebo reasoning_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