From notebook to artifact: serializing and versioning a model

A model that stays in a notebook brings no value. Deploying means making it usable by other systems: an application, a dashboard, a nightly job. This course follows a running example: a churn prediction model (customer departure), which we will save, expose as an API, containerize, test and monitor.

A single object: the Pipeline

The most frequent mistake in production is applying preprocessing that is different from training (a forgotten normalization, columns in the wrong order). You avoid it by saving the preprocessing and the model together:

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 with named columns

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

For PyTorch, you save the state_dict (torch.save(modele.state_dict(), "poids.pt")) along with the model’s class code. To serve a model from another language or speed up inference, the ONNX format (skl2onnx, torch.onnx.export) is a portable option.

Watch out for security

pickle and joblib can execute arbitrary code on loading. Never load a file whose origin you do not control (downloaded, received by email). To share scikit-learn models, the skops library offers a format that checks types before loading; for network weights, the safetensors format is the standard.

Versions matter

A model serialized with scikit-learn 1.9 may refuse to load, or behave differently, with another version. So pin your dependencies:

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

Also fix the random seeds (random_state) so you can retrain identically.

Documenting the artifact

A .joblib file on its own says nothing. Accompany it with a model card (in JSON format):

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),          # expected input order
    "metriques": {"auc_test": round(roc_auc_score(y_test, modele.predict_proba(X_test)[:, 1]), 4)},
    "sha256": hashlib.sha256(tampon.getvalue()).hexdigest(),   # artifact fingerprint
    "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)

The SHA-256 fingerprint lets you verify that the deployed file is indeed the one that was validated. The version often follows semantic versioning: major if the input contract changes, minor for a compatible retraining, patch for a minor fix.

Tools such as MLflow automate this tracking (parameters, metrics, artifacts, model registry); we will see them in lesson 4.

Key takeaways

Save a complete Pipeline, pin versions, only load trusted files and document each artifact with its features, metrics and fingerprint.