Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Versioning et Rollback

Lezione 16 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Pourquoi versionner vos modèles
  2. Nommer les versions
  3. Maintenir un registre de modèles
  4. Effectuer un rollback en quelques secondes
  5. Archiver les données, pas seulement les modèles
  6. Automatiser le pipeline complet
  7. Nettoyage
  8. Punti chiave
  9. Teste tes connaissances

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.

VersionCe que cela signale
v1.0Premier modèle validé en production
v1.1Correctif de données (mêmes hyperparamètres)
v2.0Changement de modèle de base ou de stratégie
v2.1Ajustement 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.