Du notebook à l'artefact : sérialiser et versionner un modèle

Un modèle qui reste dans un notebook n’apporte aucune valeur. Déployer, c’est le rendre utilisable par d’autres systèmes : une application, un tableau de bord, un traitement nocturne. Ce cours suit un fil rouge : un modèle de prédiction de churn (départ client), que nous allons sauvegarder, exposer en API, conteneuriser, tester et surveiller.

Un seul objet : le Pipeline

L’erreur la plus fréquente en production est d’appliquer un prétraitement différent de celui de l’entraînement (une normalisation oubliée, des colonnes dans le mauvais ordre). On l’évite en sauvegardant le prétraitement et le modèle ensemble :

import joblib
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

modele = make_pipeline(StandardScaler(), LogisticRegression())
modele.fit(X_train, y_train)               # X_train : DataFrame avec colonnes nommées

joblib.dump(modele, "modele.joblib")       # sérialisation
modele_charge = joblib.load("modele.joblib")
assert (modele_charge.predict(X_test) == modele.predict(X_test)).all()

Pour PyTorch, on sauvegarde le state_dict (torch.save(modele.state_dict(), "poids.pt")) avec le code de la classe du modèle. Pour servir un modèle depuis un autre langage ou accélérer l’inférence, le format ONNX (skl2onnx, torch.onnx.export) est une option portable.

Attention à la sécurité

pickle et joblib peuvent exécuter du code arbitraire au chargement. Ne chargez jamais un fichier dont vous ne maîtrisez pas l’origine (téléchargé, reçu par e-mail). Pour partager des modèles scikit-learn, la bibliothèque skops propose un format qui vérifie les types avant chargement ; pour les poids de réseaux, le format safetensors est la norme.

Les versions comptent

Un modèle sérialisé avec scikit-learn 1.9 peut refuser de se charger, ou se comporter différemment, avec une autre version. Figez donc vos dépendances :

# requirements.txt
scikit-learn==1.9.1
pandas==3.1.1
numpy==2.5.4
joblib==1.6.0

Fixez aussi les graines aléatoires (random_state) pour pouvoir ré-entraîner à l’identique.

Documenter l’artefact

Un fichier .joblib seul ne dit rien. Accompagnez-le d’une fiche (au format JSON) :

import hashlib, json, datetime, io
import sklearn
from sklearn.metrics import roc_auc_score

tampon = io.BytesIO()
joblib.dump(modele, tampon)
fiche = {
    "nom": "churn",
    "version": "1.0.0",
    "features": list(X_train.columns),          # ordre attendu en entrée
    "metriques": {"auc_test": round(roc_auc_score(y_test, modele.predict_proba(X_test)[:, 1]), 4)},
    "sha256": hashlib.sha256(tampon.getvalue()).hexdigest(),   # empreinte de l'artefact
    "sklearn": sklearn.__version__,
    "entraine_le": datetime.datetime.now(datetime.timezone.utc).isoformat(),
    "donnees": "clients_2026-09.parquet",
}
with open("modele.json", "w") as f:
    json.dump(fiche, f, indent=2)

L’empreinte SHA-256 permet de vérifier que le fichier déployé est bien celui qui a été validé. La version suit souvent le versionnement sémantique : majeure si le contrat d’entrée change, mineure pour un ré-entraînement compatible, correctif pour une correction mineure.

Des outils comme MLflow automatisent ce suivi (paramètres, métriques, artefacts, registre de modèles) ; nous les verrons en leçon 4.

À retenir

Sauvegardez un Pipeline complet, figez les versions, ne chargez que des fichiers de confiance et documentez chaque artefact avec ses features, ses métriques et son empreinte.