Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Uvedba fino uglašenega modela

Lekcija 14 od 16 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Od razvoja do produkcije
  2. Centraliziraj konfiguracijo
  3. Upri se incidentom
  4. Beleži tisto, kar je pomembno
  5. Preden odprete zapornice
  6. Ključne ugotovitve

Posodobitev lekcije 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra temperature in top_p sta sprejeta le pri naporu razmišljanja (reasoning effort) vrednosti none, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določiti reasoning={"effort": "none"} (API Responses) ali reasoning_effort="none" (Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.

Posodobitev 2. novembra 2026 — Razpoložljivost fino uglaševanja. Samostojno fino uglaševanje podjetja OpenAI se postopno ukinja: od 7. maja 2026 organizacije, ki še nikoli niso izvedle fino uglaševanja, ne morejo več ustvarjati opravil; od 2. julija morate biti uporabili fino uglašen model v zadnjih 60 dneh; in od 6. januarja 2027 noben uporabnik ne bo mogel zagnati novih opravil. Že usposobljeni modeli ostanejo uporabni, dokler njihov osnovni model ni upokojen. Ta tečaj je še vedno koristen za razumevanje in izkoriščanje obstoječega modela; za nove projekte dajte prednost inženiringu pozivov, RAG in evalvacijam.

Od razvoja do produkcije

Vaš fino uglašeni model je ovrednoten in odobren. Čas je, da ga uvedete v produkcijo. Ta lekcija pokriva najboljše prakse za zanesljivo, varno in vzdrževano uvedbo – vse tisto, kar loči model, ki teče na vašem prenosniku, od storitve, ki jo vaši uporabniki lahko neprekinjeno uporabljajo, ne da bi bili vi dežurni.

Začnimo z osnovami: fino uglašeni model deluje popolnoma enako kot kateri koli drug model OpenAI. Edina razlika je ime modela, ki postane dolg identifikator, vključno z vašo organizacijo, vašo pripono in ID-jem opravila. Ni dodatnih parametrov, ni posebnih končnih točk.

from openai import OpenAI

client = OpenAI()

# Fino uglašeni model ima edinstven identifikator
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)

Centraliziraj konfiguracijo

Ta identifikator ima eno posebnost, ki bi morala voditi celotno vašo arhitekturo: spremeni se z vsako novo različico vašega modela. Trdo kodiranje tega identifikatorja po celotni aplikaciji prisili popolno ponovno uvedbo za vsako najmanjšo posodobitev in povzroči dolgočasno iskanje, ko se ta pojavi na treh različnih mestih. Postavite ga v okoljsko spremenljivko, z osnovnim modelom kot nadomestno vrednostjo: vaša aplikacija se bo zagnala, tudi če spremenljivka ni nastavljena, s čimer se izognete tihi incidentni zaustavitvi storitve nedeljo zvečer.

import os

class Config:
    """Centralizirana konfiguracija modela."""

    # Okoljska spremenljivka za produkcijski model
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # nadomestni osnovni model
    )

    # Sistemski poziv (lahko je prazen, če je integriran v fino uglaševanje)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

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

Enaka logika velja za same klice. Namesto da bi razpršili klice client.responses.create po svoji poslovni logiki, jih zaprite v eno samo storitev. S tem pridobite obvezno ozko grlo, kamor lahko kasneje priklopite beleženje, metrike in nadomestne mehanizme, ne da bi morali znova odpirati dvajset datotek. Opazite, kako spodnja storitev združuje poljubni kontekst z vprašanjem in kako ujame vsako izjemo, da jo preusmeri na osnovni model.

from openai import OpenAI

class AssistantService:
    """Storitev, ki encapsulira klice fino uglašenega modela."""

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

    def repondre(self, question: str, contexte: str = "") -> str:
        """Generira odgovor."""
        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"},  # temperatura zahteva napor none
                input=input_msg,
                max_output_tokens=Config.MAX_TOKENS,
                temperature=Config.TEMPERATURE
            )
            return response.output_text

        except Exception as e:
            # Nadomestni osnovni model ob napaki
            return self._fallback(input_msg, str(e))

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

Upri se incidentom

Poslabšan odgovor je boljši od nobenega odgovora. Če je vaš fino uglašeni model začasno nedostopen, je bolje preklopiti na osnovni model – s sistemskim pozivom, ki ste ga ohranili prav za ta primer – kot da uporabniku prikažete napako. Naslednja funkcija veriži dva komplementarna mehanizma: najprej tri poskuse na primarnem modelu, razmaknjene z zamikom, ki se z vsako napako podvoji, da se izogne poslabšanju začasne preobremenitve; nato, le če vse odpove, klic nadomestnega modela. Ohranite zastavico fallback, vrnjeno v rezultatu, saj je edina uporabna sled o tem, kako pogosto se ta mehanizem dejansko sproži.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Odporne klic z ponovitvijo in nadomestnim modelom."""

    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)  # eksponentno odlašanje

    # Nadomestni model
    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}

Omejevanje hitrosti (rate limiting) zasluži ločeno obravnavo, saj ne gre za izpad, temveč za regulacijo: fino uglašeni modeli si delijo enake omejitve hitrosti kot osnovni modeli. Napaka RateLimitError preprosto zahteva, da počakate, in spodnje progresivno čakanje je dovolj za absorpcijo skoka prometa. Če pa zanka doseže svoj strop, težava ni več trenutne narave in morate pregledati svojo kvoto.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Obdelava omejevanja hitrosti s progresivnim čakanjem."""
    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")

Beleži tisto, kar je pomembno

Strukturirano beleženje pretvori neprozorne incidente v hitro diagnostiko. Za vsak klic zabeležite dejansko uporabljeni model, volumen vhoda in izhoda, zakasnitev in zastavico za nadomestni model. Te informacije zadostujejo za odgovore na vprašanja, ki se pojavijo med incidentom: kako dolgo zakasnitev že narašča, ali je povečanje stroškov posledica prometa ali daljših odgovorov in koliko uporabnikov je dejansko postregel osnovni model.

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
):
    """Strukturirano beleženje za vsak produkcijski klic."""
    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()
        }
    )

Kar zadeva konfiguracijo, vse gre v okoljsko datoteko, ki nikoli ne sme vstopiti v vaše skladišče: vsebuje vaš API ključ, objavljen ključ pa pomeni ogrožen ključ.

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

Preden odprete zapornice

Preden storitev izpostavite svojim uporabnikom, po vrsti opravite preverjanja iz te lekcije. Model mora biti ovrednoten in odobren glede na prag, ki ste ga vnaprej določili; njegovo ime mora živeti v okoljski spremenljivki in nikjer trdo kodirano; mehanizem za nadomestni model mora biti vzpostavljen. Te tri točke pogojujejo vse ostalo, saj brez njih v splet postavljate model, katerega izmerjena kakovost, točen naslov in obnašanje, ko API slabo odgovarja, so neznani.

Nato preverite instrumentacijo. Beleženje mora biti omogočeno in zapisovati vsaj uporabljeni model, zakasnitev in žetone; omejevanje hitrosti mora biti obravnavano, ne pa trpljeno; opozorila morajo biti konfigurirana glede na stopnjo napak in zakasnitev P95, sicer bo vaš prvi nezadovoljni uporabnik odigral vlogo sonde. Končno, povratni korak (rollback) mora biti dokumentiran in preizkusljiv – povratni korak, ki nikoli ni bil dejansko izveden, ostane le namen, ne mehanizem.

Ključne ugotovitve

  • Za ime modela uporabite okoljske spremenljivke
  • Vedno implementirajte preklop na osnovni model
  • Beležite vsak klic z uporabljenim modelom in zakasnitvijo
  • Obdelajte omejevanje hitrosti z eksponentnim odlašanjem
  • Pred uvedbo preizkusite svoj mehanizem za preklop