Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Egy finomhangolt modell üzembe helyezése

14. lecke 16 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. A fejlesztéstől a élesítésig
  2. Konfiguráció központosítása
  3. Ellenállás az incidensekkel szemben
  4. Naplózd, ami számít
  5. Mielőtt elengednéd a gátakat
  6. Főbb megállapítások

A leckét 2026. november 3-án frissítettük az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk a reasoning={"effort": "none"} (API Responses) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

2026. november 2-i frissítés — A finomhangolás elérhetősége. Az OpenAI saját kiszolgálású finomhangolási szolgáltatását fokozatosan megszüntetik: 2026. május 7. óta azok a szervezetek, amelyek még soha nem végeztek finomhangolást, már nem hozhatnak létre feladatokat; július 2. óta az elmúlt 60 napban használni kellett egy finomhangolt modellt; és 2027. január 6-tól kezdve egyetlen ügyfél sem indíthat új feladatokat. A már betanított modellek addig használhatók maradnak, amíg az alapmodelljüket nyugdíjba nem vonják. Ez a tanfolyam továbbra is hasznos egy meglévő modell megértéséhez és kiaknázásához; új projektek esetén előnyben részesítendő a prompt-mérnökség, a RAG és az értékelések.

A fejlesztéstől a élesítésig

A finomhangolt modelledet kiértékelték és jóváhagyták. Itt az idő, hogy éles környezetbe (production) helyezd. Ez a lecke a megbízható, biztonságos és karbantartható üzembe helyezés legjobb gyakorlatait tárgyalja – mindazt, ami elválasztja a laptopodon futó modellt attól a szolgáltatástól, amelyet a felhasználóid folyamatosan elérhetnek anélkül, hogy neked készenléti ügyeletben kellene lenned.

Kezdjük az alapokkal: egy finomhangolt modell pontosan úgy működik, mint bármely más OpenAI modell. Az egyetlen különbség a modell neve, amely egy hosszú azonosítóvá válik, tartalmazva a szervezetedet, az utótagodat (suffix) és egy feladatazonosítót (job ID). Nincsenek extra paraméterek, nincsenek speciális végpontok.

from openai import OpenAI

client = OpenAI()

# A finomhangolt modellnek egyedi azonosítója van
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)

Konfiguráció központosítása

Ennek az azonosítónak van egy sajátossága, amelynek az egész architektúrádat meghatároznia kellene: minden egyes új modellverzióval megváltozik. Ha hardcoded módon (közvetlenül a kódba írva) használod az alkalmazásodban, az a legkisebb frissítéshez is teljes újratelepítést kényszerít ki, és fárasztó keresgéléshez vezet azon a napon, amikor három különböző helyen bukkan fel. Helyezd egy környezeti változóba, az alapmodellt tartalék értékként megadva: így az alkalmazásod elindul akkor is, ha a változó nincs beállítva, elkerülve ezzel egy csendes szolgáltatási incidenset vasárnap éjjel.

import os

class Config:
    """Központosított modellkonfiguráció."""

    # Környezeti változó az éles modellhez
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # tartalék az alapmodellre
    )

    # Rendszerutasítás (üres lehet, ha be van építve a finomhangolásba)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

    # Generációs paraméterek
    MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
    TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))

Ugyanez a logika vonatkozik magukra a hívásokra is. Ahelyett, hogy szétszórnád a client.responses.create hívásokat az üzleti logikádban, zárd őket egyetlen szolgáltatásba (service). Így nyersz egy kötelező szűk keresztmetszetet, ahol később naplózást, metrikákat és tartalék megoldásokat iktathatsz be anélkül, hogy húsz fájlt kellene újra megnyitnod. Figyeld meg, hogyan építi fel az alábbi szolgáltatás az opcionális kontextust a kérdéssel, és hogyan kap el minden kivételt, hogy az alapmodellre irányítsa át a kérést.

from openai import OpenAI

class AssistantService:
    """Szolgáltatás, amely kapszulázza a finomhangolt modellhez intézett hívásokat."""

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

    def repondre(self, question: str, contexte: str = "") -> str:
        """Választ generál."""
        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"},  # a temperature megköveteli a none erőfeszítést
                input=input_msg,
                max_output_tokens=Config.MAX_TOKENS,
                temperature=Config.TEMPERATURE
            )
            return response.output_text

        except Exception as e:
            # Hiba esetén visszatérés az alapmodellhez
            return self._fallback(input_msg, str(e))

    def _fallback(self, input_msg: str, erreur: str) -> str:
        """Visszatérés az alapmodellhez."""
        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

Ellenállás az incidensekkel szemben

Egy degradált válasz jobb, mint a válasz hiánya. Ha a finomhangolt modelled átmenetileg elérhetetlen, jobb az alapmodellre váltani – azzal a rendszerutasítással, amelyet pontosan erre az esetre tartottál fenn –, mintsem hibaüzenetet megjeleníteni a felhasználónak. Az alábbi függvény két kiegészítő mechanizmust láncol össze: először három próbálkozást az elsődleges modellen, olyan késleltetéssel, amely minden kudarc esetén megduplázódik, hogy elkerülje az ideiglenes túlterhelés súlyosbítását; majd csak akkor, ha minden sikertelen, egy hívást a tartalék modellhez. Tartsd meg a resultátumban visszaadott fallback jelzőt, mivel ez az egyetlen használható nyom arra vonatkozóan, hogy ez a mechanizmus valójában milyen gyakran aktiválódik.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Ellenálló hívás újrapróbálkozással és tartalék megoldással."""

    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ális visszalépés

    # Tartalék megoldás
    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}

A sebességkorlátozás (rate limiting) külön kezelést érdemel, mert ez nem kiesés, hanem szabályozás: a finomhangolt modellek ugyanazokat a sebességkorlátokat osztják meg, mint az alapmodellek. Egy RateLimitError egyszerűen csak arra kér, hogy várj, és az alábbi progresszív várakozás elegendő egy csúcs elnyelésére. Ha azonban a ciklus eléri a plafont, a probléma már nem konjunkturális, és felül kell vizsgálnod a kvótádat.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Sebességkorlátozás kezelése progresszív várakozással."""
    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")

Naplózd, ami számít

A strukturált naplózás az átláthatatlan incidensekből gyors diagnosztikát csinál. Minden hívásnál rögzítsd a ténylegesen használt modellt, a bemenet és kimenet volumenét, a késleltetést és a tartalék megoldás jelzőt. Ez az információ elegendő ahhoz, hogy megválaszold az incidens során felmerülő kérdéseket: mióta driftel a késleltetés, a forgalom növekedése vagy a hosszabb válaszok okozzák-e a költségnövekedést, és hány felhasználót szolgált ki valójában az alapmodell.

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
):
    """Strukturált napló minden éles híváshoz."""
    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()
        }
    )

Konfigurációs oldalról minden egy olyan környezeti fájlba kerül, amelynek soha nem szabad bekerülnie a tárolódba (repository): ez tartalmazza az API-kulcsodat, és egy közzétett kulcs egy kompromittált kulcsot jelent.

# .env (ne commitold)
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

Mielőtt elengednéd a gátakat

Mielőtt kiteszed a szolgáltatást a felhasználóidnak, menj végig egyesével ezen a leckén szereplő ellenőrzéseken. A modellt ki kellett értékelni és jóvá kellett hagyni az előre meghatározott küszöbérték alapján; a nevének egy környezeti változóban kell élnie, és sehol sem lehet hardcoded; egy tartalék mechanizmusnak helyén kell lennie. Ez a három pont feltétele mindennek másnak, mert nélkülük egy olyan modellt teszel online, amelynek mért minősége, pontos címe és viselkedése az API rossz válaszai esetén ismeretlen.

Ezután ellenőrizd a műszerezettséget. A naplózásnak engedélyezve kell lennie, és legalább a használt modellt, a késleltetést és a tokeneket kell rögzítenie; a sebességkorlátozást kezelni kell, nem elszenvedni; a riasztásokat konfigurálni kell a hibaráta és a P95 késleltetés alapján, különben az első elégedetlen felhasználód fogja játszani a szonda szerepét. Végül a visszaállításnak (rollback) dokumentáltnak és tesztelhetőnek kell lennie – egy soha végre nem hajtott visszaállítás csupán szándék, nem mechanizmus.

Főbb megállapítások

  • Használj környezeti változókat a modell nevéhez
  • Mindig valósíts meg egy tartalék megoldást az alapmodellre
  • Naplózz minden hívást a használt modellel és a késleltetéssel
  • Kezeld a sebességkorlátozást exponenciális visszalépéssel
  • Teszteld a tartalék mechanizmusodat az üzembe helyezés előtt