Déployer un modèle affiné
Šiame puslapyje
Leçon mise à jour le 3 novembre 2026 selon la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, alors que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifierreasoning={"effort": "none"}(API Responses) oureasoning_effort="none"(Chat Completions). Sources : Using GPT-6 · GPT-5.6 Terra.
Mise à jour du 2 novembre 2026 — Disponibilité de l’affinage. L’affinage en libre-service d’OpenAI est en cours de suppression : depuis le 7 mai 2026, les organisations n’ayant jamais réalisé d’affinage ne peuvent plus créer de tâches ; depuis le 2 juillet, vous devez avoir utilisé un modèle affiné au cours des 60 derniers jours ; et à partir du 6 janvier 2027, aucun client ne pourra lancer de nouvelles tâches. Les modèles déjà entraînés restent utilisables jusqu’au retrait de leur modèle de base. Ce cours reste utile pour comprendre et exploiter un modèle existant ; pour les nouveaux projets, privilégiez l’ingénierie de prompt, le RAG et les évaluations.
Du développement à la production
Votre modèle affiné est évalué et approuvé. Il est temps de le déployer en production. Cette leçon couvre les bonnes pratiques pour un déploiement fiable, sécurisé et maintenable — tout ce qui sépare un modèle tournant sur votre ordinateur portable d’un service que vos utilisateurs peuvent interroger en continu sans que vous soyez d’astreinte.
Commençons par les bases : un modèle affiné fonctionne exactement comme n’importe quel autre modèle OpenAI. La seule différence réside dans le nom du modèle, qui devient un long identifiant incluant votre organisation, votre suffixe et un ID de tâche. Aucun paramètre supplémentaire, aucun point de terminaison spécial.
from openai import OpenAI
client = OpenAI()
# Le modèle affiné possède un identifiant unique
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)
Centraliser la configuration
Cet identifiant a une particularité qui doit régir toute votre architecture : il change à chaque nouvelle version de votre modèle. Le coder en dur dans toute votre application impose un redéploiement complet pour la moindre mise à jour, et une recherche fastidieuse le jour où il apparaît à trois endroits différents. Placez-le dans une variable d’environnement, avec le modèle de base comme valeur de repli : votre application démarrera même si la variable n’est pas définie, évitant ainsi un incident de service silencieux un dimanche soir.
import os
class Config:
"""Configuration centralisée du modèle."""
# Variable d'environnement pour le modèle de production
MODEL_ID = os.environ.get(
"OPENAI_FT_MODEL",
"gpt-5.6-luna" # repli sur le modèle de base
)
# Prompt système (peut être vide si intégré dans l'affinage)
SYSTEM_PROMPT = os.environ.get("SYSTEM_PROMPT", "")
# Paramètres de génération
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024"))
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
La même logique s’applique aux appels eux-mêmes. Au lieu de disperser les appels client.responses.create dans toute votre logique métier, encapsulez-les dans un seul service. Vous gagnez un point de passage obligatoire où vous pourrez ensuite brancher la journalisation, les métriques et le repli sans rouvrir vingt fichiers. Remarquez comment le service ci-dessous compose un contexte optionnel avec la question, et comment il attrape toute exception pour la rediriger vers le modèle de base.
from openai import OpenAI
class AssistantService:
"""Service encapsulant les appels au modèle affiné."""
def __init__(self):
self.client = OpenAI()
self.model = Config.MODEL_ID
def repondre(self, question: str, contexte: str = "") -> str:
"""Génère une réponse."""
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 requires effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Repli sur le modèle de base en cas d'erreur
return self._fallback(input_msg, str(e))
def _fallback(self, input_msg: str, erreur: str) -> str:
"""Repli sur le modèle de base."""
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
Résister aux incidents
Une réponse dégradée vaut mieux qu’aucune réponse. Si votre modèle affiné est temporairement indisponible, il vaut mieux basculer sur le modèle de base — avec le prompt système que vous avez conservé précisément pour ce cas — plutôt que d’afficher une erreur à l’utilisateur. La fonction suivante enchaîne deux mécanismes complémentaires : d’abord, trois tentatives sur le modèle principal, espacées d’un délai qui double à chaque échec pour éviter d’aggraver une surcharge temporaire ; ensuite, seulement si tout échoue, un appel au modèle de repli. Conservez le drapeau fallback retourné dans le résultat, car c’est la seule trace utilisable de la fréquence à laquelle ce mécanisme se déclenche réellement.
import time
def appel_resilient(
client: OpenAI,
modele_principal: str,
modele_fallback: str,
input_msg: str,
max_retries: int = 3
) -> dict:
"""Appel résilient avec nouvelle tentative et repli."""
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) # exponential backoff
# Repli
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}
La limitation de débit mérite un traitement séparé car il ne s’agit pas d’une panne mais d’une régulation : les modèles affinés partagent les mêmes limites de débit que les modèles de base. Une RateLimitError vous demande simplement d’attendre, et l’attente progressive ci-dessous suffit à absorber un pic. Si la boucle atteint son plafond, cependant, le problème n’est plus conjoncturel et vous devez revoir votre quota.
from openai import RateLimitError
import time
def appel_avec_rate_limit(client, modele, input_msg, max_wait=60):
"""Gère la limitation de débit avec une attente progressive."""
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")
Journaliser l’essentiel
La journalisation structurée transforme des incidents opaques en diagnostics rapides. Pour chaque appel, enregistrez le modèle réellement utilisé, le volume d’entrée et de sortie, la latence et le drapeau de repli. Ces informations suffisent à répondre aux questions qui surgissent lors d’un incident : depuis combien de temps la latence dérive-t-elle, l’augmentation des coûts est-elle due au trafic ou à des réponses plus longues, et combien d’utilisateurs ont réellement été servis par le modèle de base.
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
):
"""Journalisation structurée pour chaque appel en production."""
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()
}
)
Côté configuration, tout va dans un fichier d’environnement qui ne doit jamais entrer dans votre dépôt : il contient votre clé API, et une clé publiée est une clé compromise.
# .env (ne pas committer)
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
Avant d’ouvrir les vannes
Avant d’exposer le service à vos utilisateurs, passez en revue les vérifications de cette leçon une par une. Le modèle doit avoir été évalué et approuvé par rapport au seuil que vous avez défini à l’avance ; son nom doit vivre dans une variable d’environnement et nulle part ailleurs en dur ; un mécanisme de repli doit être en place. Ces trois points conditionnent tout le reste, car sans eux, vous mettez en ligne un modèle dont la qualité mesurée, l’adresse exacte et le comportement lorsque l’API répond mal sont inconnus.
Ensuite, vérifiez l’instrumentation. La journalisation doit être activée et enregistrer au minimum le modèle utilisé, la latence et les tokens ; la limitation de débit doit être gérée plutôt que subie ; des alertes doivent être configurées sur le taux d’erreur et la latence P95, sinon votre premier utilisateur mécontent jouera le rôle de la sonde. Enfin, le retour arrière (rollback) doit être documenté et testable — un retour arrière jamais réellement exécuté reste une intention, pas un mécanisme.
Svarbiausi punktai
- Utilise des variables d’environnement pour le nom du modèle
- Implémente toujours un repli vers le modèle de base
- Journalise chaque appel avec le modèle utilisé et la latence
- Gère la limitation de débit avec un backoff exponentiel
- Teste ton mécanisme de repli avant le déploiement