Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Een fine-getuned model implementeren

Les 14 van 16 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Van ontwikkeling naar productie
  2. Centraliseer configuratie
  3. Weersta incidenten
  4. Log wat belangrijk is
  5. Voordat u de sluizen opent
  6. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (API Responses) of reasoning_effort="none" (Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.

Update 2 november 2026 — Beschikbaarheid fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd uitgefaseerd: sinds 7 mei 2026 kunnen organisaties die nog nooit fine-tuning hebben uitgevoerd geen taken meer maken; sinds 2 juli moet u binnen de laatste 60 dagen een fine-getuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.

Van ontwikkeling naar productie

Uw fine-getuned model is geëvalueerd en goedgekeurd. Het is tijd om het in productie te nemen. Deze les behandelt best practices voor een betrouwbare, veilige en onderhoudbare implementatie—alles wat het verschil maakt tussen een model dat op uw laptop draait en een service die uw gebruikers continu kunnen aanspreken zonder dat u constant beschikbaar hoeft te zijn.

Laten we beginnen met de basis: een fine-getuned model werkt precies zoals elk ander OpenAI-model. Het enige verschil is de modelnaam, die een lange identifier wordt met uw organisatie, uw achtervoegsel en een taak-ID. Geen extra parameters, geen speciale endpoints.

from openai import OpenAI

client = OpenAI()

# Het fine-getuned model heeft een unieke 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)

Centraliseer configuratie

Deze identifier heeft één eigenaardigheid die uw hele architectuur moet sturen: deze verandert bij elke nieuwe versie van uw model. Als u deze hard-codeert in uw hele applicatie, forceert u een volledige herimplementatie voor de kleinste update, en een vervelende zoektocht op de dag dat deze op drie verschillende plekken verschijnt. Zet het in een omgevingsvariabele, met het basismodel als fallback-waarde: uw applicatie start zelfs als de variabele niet is ingesteld, waardoor een stille service-incidents op een zondagavond wordt voorkomen.

import os

class Config:
    """Gecentraliseerde modelconfiguratie."""

    # Omgevingsvariabele voor het productiemodel
    MODEL_ID = os.environ.get(
        "OPENAI_FT_MODEL",
        "gpt-5.6-luna"  # fallback naar basismodel
    )

    # Systeemprompt (kan leeg zijn als geïntegreerd in fine-tuning)
    SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")

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

Dezelfde logica geldt voor de aanroepen zelf. In plaats van client.responses.create-aanroepen te verspreiden door uw bedrijfslogica, kapselt u ze in in één enkele service. U wint een verplicht knelpunt waar u later logging, metrics en fallback aan kunt koppelen zonder twintig bestanden opnieuw te openen. Merk op hoe de onderstaande service een optionele context samenstelt met de vraag, en hoe deze elke uitzondering opvangt om deze door te sturen naar het basismodel.

from openai import OpenAI

class AssistantService:
    """Service die aanroepen naar het fine-getuned model kapselt."""

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

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

        except Exception as e:
            # Fallback naar basismodel bij fout
            return self._fallback(input_msg, str(e))

    def _fallback(self, input_msg: str, erreur: str) -> str:
        """Fallback naar basismodel."""
        print(f"Fallback geactiveerd: {erreur}")
        response = self.client.responses.create(
            model="gpt-5.6-luna",
            instructions=Config.SYSTEM_PROMPT,
            input=input_msg
        )
        return response.output_text

Weersta incidenten

Een gedegradeerd antwoord is beter dan geen antwoord. Als uw fine-getuned model tijdelijk niet beschikbaar is, is het beter om over te schakelen op het basismodel—met de systeemprompt die u precies voor dit geval hebt bewaard—dan om een fout aan de gebruiker te tonen. De volgende functie koppelt twee complementaire mechanismen: eerst drie pogingen op het primaire model, met tussenpozen die bij elke mislukking verdubbelen om een tijdelijke overbelasting niet te verergeren; daarna, alleen als alles faalt, een aanroep naar het fallback-model. Houd de fallback-vlag die in het resultaat wordt teruggegeven bij, want dit is het enige bruikbare spoor van hoe vaak dit mechanisme daadwerkelijk activeert.

import time

def appel_resilient(
    client: OpenAI,
    modele_principal: str,
    modele_fallback: str,
    input_msg: str,
    max_retries: int = 3
) -> dict:
    """Veerkrachtige aanroep met retry en fallback."""

    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"Poging {tentative + 1} mislukt: {e}")
            if tentative < max_retries - 1:
                time.sleep(2 ** tentative)  # exponentiële backoff

    # Fallback
    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}

Rate limiting verdient een aparte behandeling omdat het geen uitval is maar een regulering: fine-getuned modellen delen dezelfde rate limits als basismodellen. Een RateLimitError vraagt u simpelweg om te wachten, en het progressieve wachten hieronder is voldoende om een piek op te vangen. Als de lus echter zijn plafond bereikt, is het probleem niet langer conjunctureel en moet u uw quota herzien.

from openai import RateLimitError
import time

def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
    """Verwerkt rate limiting met progressief wachten."""
    wait = 1
    while wait <= max_wait:
        try:
            return client.responses.create(
                model=modele,
                input=input_msg
            )
        except RateLimitError:
            print(f"Rate limit bereikt, wachten {wait}s...")
            time.sleep(wait)
            wait *= 2

    raise Exception("Aanhoudende rate limit — controleer uw quota")

Log wat belangrijk is

Gestructureerde logging verandert ondoorzichtige incidenten in snelle diagnostics. Leg voor elke aanroep het daadwerkelijk gebruikte model, het volume van input en output, de latentie en de fallback-vlag vast. Deze informatie is voldoende om de vragen te beantwoorden die tijdens een incident rijzen: hoe lang drifft de latentie al, komt de kostenstijging door verkeer of langere antwoorden, en hoeveel gebruikers werden daadwerkelijk bediend door het basismodel.

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
):
    """Gestructureerde log voor elke productieaanroep."""
    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()
        }
    )

Aan de configuratiekant gaat alles naar een omgevingsbestand dat nooit in uw repository mag komen: het bevat uw API-sleutel, en een gepubliceerde sleutel is een gecompromitteerde sleutel.

# .env (niet committen)
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

Voordat u de sluizen opent

Voordat u de service blootstelt aan uw gebruikers, doorloopt u de controles in deze les één voor één. Het model moet zijn geëvalueerd en goedgekeurd tegen de drempel die u vooraf hebt gedefinieerd; de naam moet in een omgevingsvariabele staan en nergens hard-gecodeerd; er moet een fallback-mechanisme aanwezig zijn. Deze drie punten conditioneren al het andere, want zonder ze brengt u een model online waarvan de gemeten kwaliteit, het exacte adres en het gedrag wanneer de API slecht reageert, onbekend zijn.

Controleer vervolgens de instrumentatie. Logging moet zijn ingeschakeld en ten minste het gebruikte model, de latentie en tokens registreren; rate limiting moet worden beheerd in plaats van ondergaan; alerts moeten zijn geconfigureerd op foutpercentage en P95-latentie, anders zal uw eerste ontevreden gebruiker de rol van de sonde spelen. Tot slot moet rollback gedocumenteerd en testbaar zijn—een rollback die nooit daadwerkelijk is uitgevoerd, blijft een intentie, geen mechanisme.

Belangrijkste punten

  • Gebruik omgevingsvariabelen voor de modelnaam
  • Implementeer altijd een fallback naar het basismodel
  • Log elke aanroep met het gebruikte model en de latentie
  • Verwerk rate limiting met exponentiële backoff
  • Test uw fallback-mechanisme voordat u implementeert