Déploiement d'un modèle fine-tuné
Na ovoj stranici
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é du fine-tuning. Le fine-tuning en libre-service d’OpenAI est en cours de suppression : depuis le 7 mai 2026, les organisations n’ayant jamais effectué de fine-tuning ne peuvent plus créer de jobs ; depuis le 2 juillet, vous devez avoir utilisé un modèle fine-tuné au cours des 60 derniers jours ; et à partir du 6 janvier 2027, aucun client ne pourra lancer de nouveaux jobs. 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 fine-tuné 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 fine-tuné 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 job. Aucun paramètre supplémentaire, aucun endpoint spécial.
from openai import OpenAI
client = OpenAI()
# Le modèle fine-tuné 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)
Centralisez la configuration
Cet identifiant a une particularité qui doit gouverner 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 vers le modèle de base
)
# Prompt système (peut être vide si intégré au fine-tuning)
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 service unique. Vous gagnez un point de passage obligatoire où vous pourrez brancher ultérieurement 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 fine-tuné."""
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 requiert effort none
input=input_msg,
max_output_tokens=Config.MAX_TOKENS,
temperature=Config.TEMPERATURE
)
return response.output_text
except Exception as e:
# Repli vers 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 vers le modèle de base."""
print(f"Repli activé : {erreur}")
response = self.client.responses.create(
model="gpt-5.6-luna",
instructions=Config.SYSTEM_PROMPT,
input=input_msg
)
return response.output_text
Résistez aux incidents
Une réponse dégradée vaut mieux qu’aucune réponse. Si votre modèle fine-tuné 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 — 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 exploitable de la fréquence réelle de déclenchement de ce mécanisme.
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 réessai 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"Tentative {tentative + 1} échouée : {e}")
if tentative < max_retries - 1:
time.sleep(2 ** tentative) # backoff exponentiel
# 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 (rate limiting) mérite un traitement séparé car il ne s’agit pas d’une panne mais d’une régulation : les modèles fine-tunés partagent les mêmes limites de débit que les modèles de base. Une RateLimitError 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"Limite de débit atteinte, attente de {wait}s...")
time.sleep(wait)
wait *= 2
raise Exception("Limite de débit persistante — vérifiez vos quotas")
Journalisez 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 passe 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 au préalable ; son nom doit vivre dans une variable d’environnement et nulle part 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.
Ključne točke
- Utilisez des variables d’environnement pour le nom du modèle
- Implémentez toujours un repli vers le modèle de base
- Journalisez chaque appel avec le modèle utilisé et la latence
- Gérez la limitation de débit avec un backoff exponentiel
- Testez votre mécanisme de repli avant le déploiement