Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Ota hienosäädetty malli käyttöön tuotannossa

Oppitunti 14 / 16 Päivitetty 3. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Kehityksestä tuotantoon
  2. Keskitä konfiguraatio
  3. Kestä häiriötilanteet
  4. Lokita oleelliset asiat
  5. Ennen kuin avaat padot
  6. Keskeiset asiat

Oppitunti päivitetty 3. marraskuuta 2026 OpenAI:n dokumentaation perusteella: parametrit temperature ja top_p hyväksytään vain, jos päättelypyrkimys (reasoning effort) on none, kun taas GPT-5.6-mallit käyttävät oletusarvoisesti päättelyä (medium). Näitä parametreja asettavien kutsujen on siksi määritettävä reasoning={"effort": "none"} (API Responses) tai reasoning_effort="none" (Chat Completions). Lähteet: Using GPT-6 · GPT-5.6 Terra.

2. marraskuuta 2026 päivitys — Hienosäädön saatavuus. OpenAI lopettaa vähitellen itsepalveluhienosäädön: 7. toukokuuta 2026 lähtien organisaatiot, jotka eivät ole koskaan suorittaneet hienosäätöä, eivät voi enää luoda tehtäviä; 2. heinäkuuta lähtien hienosäädettyä mallia on täytynyt käyttää viimeisen 60 päivän aikana; ja 6. tammikuuta 2027 alkaen mikään asiakas ei voi enää käynnistää uusia tehtäviä. Jo koulutetut mallit pysyvät käytössä, kunnes niiden pohjamalli poistetaan käytöstä. Tämä kurssi on edelleen hyödyllinen olemassa olevan mallin ymmärtämiseen ja hyödyntämiseen; uusissa projekteissa priorisoi kehotetekniikkaa (prompt engineering), RAG:ia ja arviointeja.

Kehityksestä tuotantoon

Hienosäädetty mallisi on arvioitu ja hyväksytty. On aika ottaa se käyttöön tuotannossa. Tämä oppitunti käsittelee parhaita käytäntöjä luotettavaan, turvalliseen ja ylläpidettävään käyttöönottoon – kaikkea sitä, mikä erottaa kannettavalla tietokoneella pyörivän mallin palvelusta, jota käyttäjät voivat käyttää jatkuvasti ilman, että sinun tarvitsee olla päivystyksessä.

Aloitetaan perusteista: hienosäädetty malli toimii täsmälleen kuten mikä tahansa muu OpenAI-malli. Ainoa ero on mallin nimi, joka muuttuu pitkäksi tunnisteeksi, joka sisältää organisaatiosi, päätteesi (suffix) ja tehtävätunnuksen. Ei lisäparametreja, ei erityisiä päätepisteitä.

from openai import OpenAI

client = OpenAI()

# Hienosäädetyllä mallilla on yksilöllinen tunniste
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)

Keskitä konfiguraatio

Tällä tunnisteella on yksi erikoisuus, jonka tulisi ohjata koko arkkitehtuuriasi: se muuttuu joka kerta, kun mallistasi julkaistaan uusi versio. Tunnisteen kovakoodaaminen sovellukseesi pakottaa täydellisen uudelleenkäyttöönoton pienimmänkin päivityksen yhteydessä ja aiheuttaa vaivalloista etsintää sinä päivänä, kun se ilmestyy kolmeen eri paikkaan. Sijoita se ympäristömuuttujaan, jossa pohjamalli toimii varoarvona: sovelluksesi käynnistyy silloinkin, jos muuttujaa ei ole asetettu, mikä estää hiljaisen palvelukatkon sunnuntai-iltana.

import os

class Config:
    """Keskitetty mallikonfiguraatio."""

    # Ympäristömuuttuja tuotantomallille
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # varoarvo pohjamalliin
    )

    # Järjestelmäkehote (voi olla tyhjä, jos integroitu hienosäätöön)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

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

Sama logiikka pätee itse kutsuihin. Sen sijaan, että hajauttaisit client.responses.create-kutsuja liiketoimintalogiikkaasi, kapseloi ne yhteen palveluun. Saat pakollisen pullonkaulan, johon voit myöhemmin liittää lokitusta, mittareita ja varajärjestelmiä avaamatta kahtakymmentä tiedostoa uudelleen. Huomaa, kuinka alla oleva palvelu yhdistää valinnaisen kontekstin kysymykseen ja kuinka se sieppaa kaikki poikkeukset ohjatakseen ne pohjamallille.

from openai import OpenAI

class AssistantService:
    """Palvelu, joka kapseloi kutsut hienosäädettyyn malliin."""

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

    def repondre(self, question: str, contexte: str = "") -> str:
        """Generoi vastauksen."""
        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 vaatii effort: none
                input=input_msg,
                max_output_tokens=Config.MAX_TOKENS,
                temperature=Config.TEMPERATURE
            )
            return response.output_text

        except Exception as e:
            # Siirry pohjamalliin virhetilanteessa
            return self._fallback(input_msg, str(e))

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

Kestä häiriötilanteet

Heikentynyt vastaus on parempi kuin ei vastausta ollenkaan. Jos hienosäädetty mallisi on väliaikaisesti tavoittamaton, on parempi vaihtaa pohjamalliin – käyttäen järjestelmäkehotetta, jonka pidit juuri tätä tapausta varten – kuin näyttää käyttäjälle virheilmoitus. Seuraava funktio ketjuttaa kaksi toisiaan täydentävää mekanismia: ensin kolme yritystä ensisijaisella mallilla, viiveellä, joka kaksinkertaistuu jokaisen epäonnistumisen jälkeen väliaikaisen ylikuormituksen pahentamisen välttämiseksi; sitten, vain jos kaikki epäonnistuu, kutsu varamallille. Pidä tuloksessa palautettu fallback-lippu, sillä se on ainoa käyttökelpoinen jälki siitä, kuinka usein tämä mekanismi todella aktivoituu.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Joustava kutsu uudelleenyrityksillä ja varajärjestelmällä."""

    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)  # eksponentiaalinen viive

    # Varajärjestelmä
    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}

Nopeusrajoitukset (rate limiting) ansaitsevat erillisen käsittelyn, koska ne eivät ole katkos vaan säätelyä: hienosäädetyillä malleilla on samat nopeusrajoitukset kuin pohjamalleilla. RateLimitError pyytää sinua vain odottamaan, ja alla oleva progressiivinen odotus riittää piikin tasaamiseen. Jos silmukka kuitenkin saavuttaa katon, ongelma ei ole enää tilapäinen, vaan sinun on tarkistettava kiintiösi.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Käsittelee nopeusrajoitukset progressiivisella odotuksella."""
    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")

Lokita oleelliset asiat

Strukturoitu lokitus muuttaa läpinäkymättömät häiriötilanteet nopeiksi diagnooseiksi. Kirjaa jokaiselle kutsulle todella käytetty malli, syötteen ja tulosteen koko, viive ja varajärjestelmä-lippu. Nämä tiedot riittävät vastaamaan kysymyksiin, jotka nousevat esiin häiriötilanteessa: kuinka kauan viive on kasvanut, johtuuko kustannusten nousu liikenteestä vai pidemmistä vastauksista, ja kuinka monta käyttäjää pohjamalli todella palveli.

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
):
    """Strukturoitu loki jokaiselle tuotantokutsulle."""
    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()
        }
    )

Konfiguraation osalta kaikki menee ympäristötiedostoon, jonka ei tule koskaan päätyä versiohallintaan: se sisältää API-avaimesi, ja julkaistu avain on kompromissoitunut avain.

# .env (älä commitoi)
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

Ennen kuin avaat padot

Ennen kuin altistat palvelun käyttäjillesi, käy läpi tämän oppitunnin tarkistuslistan kohta kohdalta. Mallin on täytynyt olla arvioitu ja hyväksytty ennaltamääritettyä kynnysarvoa vasten; sen nimen on sijaittava ympäristömuuttujassa eikä missään kovakoodattuna; varajärjestelmän on oltava paikallaan. Nämä kolme kohtaa ovat kaiken edellytys, sillä ilman niitä otat käyttöön mallin, jonka mitattu laatu, tarkka osoite ja käyttäytyminen API:n huonosti vastatessa ovat tuntemattomia.

Tarkista seuraavaksi instrumentointi. Lokituksen on oltava käytössä ja sen on kirjattava vähintään käytetty malli, viive ja tokenit; nopeusrajoitukset on käsiteltävä eikä niitä saa vain kärsiä; hälytykset on määritettävä virheprosentille ja P95-viiveelle, muuten ensimmäinen tyytymätön käyttäjäsi joutuu koekaniinin rooliin. Lopuksi palautuksen (rollback) on oltava dokumentoitu ja testattavissa – palautusta, jota ei ole koskaan todella suoritettu, pidetään aikomuksena, ei mekanismina.

Keskeiset asiat

  • Käytä ympäristömuuttujia mallin nimeä varten
  • Toteuta aina varajärjestelmä pohjamallille
  • Lokita jokainen kutsu käytetyn mallin ja viiveen kanssa
  • Käsittele nopeusrajoitukset eksponentiaalisella viiveellä
  • Testaa varajärjestelmäsi ennen käyttöönottoa