Versioning et Rollback
In questa pagina
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 qui ne l’ont jamais utilisé 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 le prompt engineering, le RAG et les évaluations.
Pourquoi versionner vos modèles
En production, vous itérerez sur votre modèle fine-tuné : nouvelles données, hyperparamètres ajustés, nouveau modèle de base. Sans un système de versioning rigoureux, vous perdrez la traçabilité et la capacité de revenir en arrière en cas de régression. Le scénario est toujours le même : un lundi matin, les retours utilisateurs se dégradent, personne ne sait quel modèle tourne réellement ni quelles données l’ont produit, et l’équipe passe la journée à reconstituer des informations qu’un fichier de quelques lignes aurait préservées.
Nommer les versions
Le paramètre suffix du job de fine-tuning est votre premier outil de traçabilité : la chaîne que vous y placez se retrouve dans l’ID final du modèle et reste lisible partout — dans vos logs, votre configuration, votre console. Adoptez une convention et tenez-vous-y.
# Convention : {nom}-v{version_majeure}.{version_mineure}
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
model="gpt-5.6-luna",
suffix="support-client-v2.1"
)
Le numéro lui-même doit porter une information, pas simplement compter les tentatives. Une version majeure change lorsque la nature du modèle change ; une version mineure, lorsque vous améliorez sans casser. Concrètement, un correctif de données appliqué avec les mêmes hyperparamètres reste sur la même version majeure, tandis qu’un changement de modèle de base nécessite d’en commencer une nouvelle.
| Version | Ce que cela signale |
|---|---|
| v1.0 | Premier modèle validé en production |
| v1.1 | Correctif de données (mêmes hyperparamètres) |
| v2.0 | Changement de modèle de base ou de stratégie |
| v2.1 | Ajustement des hyperparamètres |
Maintenir un registre de modèles
Le nom seul ne suffit pas : il ne dit rien sur le contenu du dataset, les résultats obtenus, ni pourquoi cette version a été promue. Un registre centralisé conserve ces métadonnées aux côtés de l’ID technique et devient la source unique de vérité de votre équipe. La classe ci-dessous garde l’essentiel dans un fichier JSON : elle enregistre un modèle candidat, en promeut un en production tout en marquant le précédent comme retiré, renvoie l’ID actuellement actif et affiche l’historique. Prenez le temps de remplir le champ notes : une seule phrase sur ce qui a changé depuis la version précédente vous fera gagner une demi-journée d’archéologie plus tard.
import json
import datetime
class ModelRegistry:
"""Registre des modèles fine-tunés."""
def __init__(self, path: str = "model_registry.json"):
self.path = path
try:
with open(path, "r") as f:
self.registry = json.load(f)
except FileNotFoundError:
self.registry = {"models": [], "production": None}
def record(
self,
version: str,
model_id: str,
job_id: str,
dataset_info: dict,
hyperparams: dict,
metrics: dict,
notes: str = ""
):
"""Enregistre un nouveau modèle dans le registre."""
entry = {
"version": version,
"model_id": model_id,
"job_id": job_id,
"date": datetime.datetime.now().isoformat(),
"dataset": dataset_info,
"hyperparameters": hyperparams,
"metrics": metrics,
"notes": notes,
"status": "candidate"
}
self.registry["models"].append(entry)
self._save()
print(f"Modèle {version} enregistré : {model_id}")
def promote(self, version: str):
"""Promouvoit un modèle en production."""
old = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
m["status"] = "production"
self.registry["production"] = version
break
if old:
for m in self.registry["models"]:
if m["version"] == old:
m["status"] = "retired"
self._save()
print(f"Production : {old} -> {version}")
def rollback(self, version: str):
"""Retour à une version précédente."""
self.promote(version)
print(f"Rollback effectué vers {version}")
def production_model(self) -> str:
"""Renvoie l'ID du modèle en production."""
version = self.registry["production"]
for m in self.registry["models"]:
if m["version"] == version:
return m["model_id"]
return None
def history(self):
"""Affiche l'historique des modèles."""
print(f"{'Version':<12} {'Statut':<12} {'Date':<12} {'Val Loss':<10}")
print("-" * 50)
for m in self.registry["models"]:
date = m["date"][:10]
loss = m["metrics"].get("validation_loss", "N/A")
print(f"{m['version']:<12} {m['status']:<12} {date:<12} {loss}")
def _save(self):
with open(self.path, "w") as f:
json.dump(self.registry, f, indent=2, ensure_ascii=False)
En pratique, le cycle de vie d’une version se résume à trois appels : vous enregistrez le modèle sortant de l’entraînement avec ses chiffres, vous le promouvez lorsque l’évaluation le valide, et vous revenez à la version précédente si la production contredit l’évaluation. Cette dernière ligne doit être aussi triviale à écrire que les deux premières.
registry = ModelRegistry()
# Enregistrer un nouveau modèle
registry.record(
version="v2.1",
model_id="ft:gpt-5.6-luna:org::support-v2.1:abc123",
job_id="ftjob-xyz789",
dataset_info={"train": 350, "validation": 45},
hyperparams={"n_epochs": 3, "lr": "auto"},
metrics={"validation_loss": 0.38, "precision_test": 0.93},
notes="Ajout de 50 exemples de correction pour les remboursements"
)
# Promouvoir en production
registry.promote("v2.1")
# En cas de problème, rollback
registry.rollback("v2.0")
Effectuer un rollback en quelques secondes
Un rollback n’a de valeur que s’il est rapide et ne nécessite aucune réflexion. Puisque votre application lit le nom du modèle depuis une variable d’environnement, changer de version signifie changer cette variable et mettre à jour le registre — aucun redéploiement de code, aucune recompilation. La fonction quick_rollback va plus loin en contournant totalement le choix humain : elle récupère la dernière version stable disponible et, si aucune n’existe, revient au modèle de base. Cette dernière branche est votre filet de sécurité absolu ; déclenchez-la volontairement une fois dans un environnement de test, alors que les enjeux sont nuls.
import os
def deploy_model(version: str, registry: ModelRegistry):
"""Déploie un modèle en mettant à jour la variable d'environnement."""
model_id = None
for m in registry.registry["models"]:
if m["version"] == version:
model_id = m["model_id"]
break
if not model_id:
raise ValueError(f"Version {version} introuvable")
# Mise à jour de la configuration
os.environ["OPENAI_FT_MODEL"] = model_id
registry.promote(version)
print(f"Modèle déployé : {version} ({model_id})")
return model_id
def quick_rollback(registry: ModelRegistry):
"""Retour à la dernière version stable."""
production = registry.registry["production"]
versions = [
m for m in registry.registry["models"]
if m["version"] != production and m["status"] != "retired"
]
if not versions:
# Repli sur le modèle de base
os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
print("Retour au modèle de base")
return
last_stable = versions[-1]
deploy_model(last_stable["version"], registry)
Archiver les données, pas seulement les modèles
Versionner un modèle sans versionner ce qui l’a produit ne vous mène qu’à mi-chemin. Le jour où vous voudrez comprendre pourquoi la v2.1 tenait mieux le ton que la v2.2, vous aurez besoin des trois fichiers exacts utilisés pour l’entraîner, y compris le jeu de test — sans cela, aucune comparaison ultérieure n’est juste. Archivez-les dans un dossier portant le numéro de version, au moment même où vous enregistrez le modèle.
import shutil
def archive_dataset(version: str, files: list[str], archive_folder: str):
"""Archive les données d'entraînement pour une version donnée."""
folder = f"{archive_folder}/{version}"
os.makedirs(folder, exist_ok=True)
for file in files:
shutil.copy2(file, folder)
print(f"Données archivées dans {folder}")
archive_dataset(
"v2.1",
["train.jsonl", "validation.jsonl", "test.jsonl"],
"archives/datasets"
)
Automatiser le pipeline complet
Ces étapes, exécutées à la main, finissent par être sautées — surtout l’archivage, qui vient en dernier et ne bloque rien. Regroupez-les dans un seul script qui enchaîne l’upload des fichiers, le lancement du job, l’attente de la fin, l’enregistrement dans le registre, puis l’archivage des données. La boucle d’attente interroge le job toutes les trente secondes et s’arrête sur un statut terminal ; en cas d’échec, la fonction retourne immédiatement plutôt que de continuer avec un modèle inexistant.
def deployment_pipeline(
training_file: str,
validation_file: str,
version: str,
base_model: str = "gpt-5.6-luna",
hyperparams: dict = None
):
"""Pipeline complet : upload, entraînement, évaluation, enregistrement."""
client = OpenAI()
registry = ModelRegistry()
# 1. Upload
print("Upload des données...")
train = client.files.create(file=open(training_file, "rb"), purpose="fine-tune")
val = client.files.create(file=open(validation_file, "rb"), purpose="fine-tune")
# 2. Entraînement
print("Lancement du fine-tuning...")
params = {"training_file": train.id, "validation_file": val.id,
"model": base_model, "suffix": version}
if hyperparams:
params["hyperparameters"] = hyperparams
job = client.fine_tuning.jobs.create(**params)
# 3. Attente de la fin
import time
while True:
job = client.fine_tuning.jobs.retrieve(job.id)
if job.status in ("succeeded", "failed"):
break
time.sleep(30)
if job.status == "failed":
print(f"Échec : {job.error}")
return None
# 4. Enregistrement
registry.record(
version=version,
model_id=job.fine_tuned_model,
job_id=job.id,
dataset_info={"train": training_file, "validation": validation_file},
hyperparams=hyperparams or {},
metrics={"trained_tokens": job.trained_tokens}
)
# 5. Archivage des données
archive_dataset(version, [training_file, validation_file], "archives/datasets")
print(f"Pipeline terminé : {job.fine_tuned_model}")
return job.fine_tuned_model
Nettoyage
Les modèles fine-tunés sont stockés sur OpenAI et peuvent être supprimés lorsque vous n’en avez plus besoin. Après une douzaine d’itérations, la liste devient illisible et le tri manuel dangereux. Le nettoyage automatique ci-dessous conserve les trois versions les plus récentes et ne touche jamais à celle qui tourne en production. Évitez d’être trop agressif : c’est précisément l’avant-dernière version, souvent jugée inutile, qui vous sauvera lors d’un rollback.
def clean_old_models(registry: ModelRegistry, keep: int = 3):
"""Supprime les anciens modèles en gardant les N derniers."""
models = registry.registry["models"]
production = registry.registry["production"]
candidates = [
m for m in models
if m["version"] != production
]
to_delete = candidates[:-keep] if len(candidates) > keep else []
for m in to_delete:
try:
client.models.delete(m["model_id"])
print(f"Supprimé : {m['version']} ({m['model_id']})")
except Exception as e:
print(f"Erreur lors de la suppression de {m['version']} : {e}")
Punti chiave
- Utilise des suffixes versionnés pour identifier chaque modèle
- Maintiens un registre centralisé avec métriques et métadonnées
- Implémente un mécanisme de rollback rapide
- Archive les données d’entraînement à chaque version
- Automatise le pipeline et nettoie régulièrement les anciens modèles : moins d’erreurs humaines, moins de coûts inutiles
Teste tes connaissances
Avant de versionner tes modèles, valide le cycle complet de fine-tuning.
1. Quand le fine-tuning est-il le bon outil — et quand ne l'est-il pas ?
Réponse : Idéal pour ancrer un style, un format ou un comportement récurrent que le prompting n’atteint pas de façon fiable ; mauvais pour injecter de nouvelles connaissances — c’est le rôle du RAG.
2. Qu'est-ce qui rend un dataset d'entraînement de haute qualité ?
Réponse : Des exemples propres, cohérents et représentatifs au format JSONL conversationnel : quelques centaines d’excellents exemples valent mieux que des milliers d’exemples bruités.
3. Qu'apporte le DPO par rapport au fine-tuning supervisé ?
Réponse : L’apprentissage par préférence : tu fournis des paires de réponses préférées/rejetées, et le modèle apprend ce qui est « meilleur » plutôt que la simple imitation — utile pour le ton et les arbitrages fins.
4. Comment valider un modèle fine-tuné ?
Réponse : En le comparant au modèle de base sur un jeu d’évaluation gardé séparé de l’entraînement, puis par des tests A/B sur des métriques métier — jamais sur une simple impression.
5. Pourquoi versionner et prévoir un rollback ?
Réponse : Chaque fine-tuning produit un modèle daté : en cas de régression en production, tu reviens immédiatement à la version précédente — le modèle se gère comme du code.
Des données propres, une évaluation honnête, des versions contrôlées : le fine-tuning est une discipline d’ingénierie — ce cours t’a donné le cycle complet.