Enregistrer et charger une chaîne de traitement avec joblib
Vous sérialiserez une chaîne de traitement ajustée sur le disque avec joblib.dump, puis la rechargerez dans une nouvelle session Python afin d’effectuer des prédictions sans nouvel entraînement.
Enregistrer et charger une chaîne de traitement avec joblib est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.
Pourquoi conserver une chaîne de traitement entraînée ?
L’entraînement d’une chaîne de traitement d’apprentissage automatique peut prendre plusieurs minutes ou plusieurs heures. Une fois celle-ci ajustée, vous souhaitez l’enregistrer sur le disque afin de pouvoir la recharger ultérieurement pour effectuer des prédictions sans la réentraîner. La persistance est également essentielle pour le déploiement : vous entraînez le modèle sur une machine de développement et fournissez les prédictions sur un serveur de production. Le fichier enregistré doit inclure à la fois les étapes de prétraitement et les poids du modèle.
Deux options de sérialisation : pickle et joblib
Le module intégré pickle de Python peut sérialiser n’importe quel objet Python, y compris les chaînes de traitement sklearn. joblib est une bibliothèque tierce (fournie avec scikit-learn) généralement privilégiée pour les objets d’apprentissage automatique, car elle est plus efficace avec les grands tableaux NumPy — en utilisant le mappage mémoire plutôt qu’une copie — et peut compresser automatiquement le fichier de sortie.
import pickle
import joblib
# Both approaches work; joblib is recommended for sklearn objects
print('pickle version:', pickle.HIGHEST_PROTOCOL)
import sklearn
print('sklearn version:', sklearn.__version__)Enregistrer avec joblib.dump
joblib.dump(obj, filename) sérialise la chaîne de traitement dans un fichier. Vous pouvez définir facultativement compress=3 pour utiliser la compression zlib (niveaux 1 à 9 ; le niveau 3 offre un bon compromis entre vitesse et taille). La fonction renvoie une liste des fichiers créés. Pour la plupart des chaînes de traitement, un seul fichier .pkl ou .joblib est créé.
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(C=1.0, max_iter=200))
])
pipe.fit(X, y)
# Save
joblib.dump(pipe, '/tmp/iris_pipeline.joblib')
print('Pipeline saved!')Charger avec joblib.load
joblib.load(filename) désérialise la chaîne de traitement pour la retransformer en objet Python. La chaîne de traitement chargée est identique à l’originale : elle possède les mêmes paramètres ajustés du dispositif de mise à l’échelle (moyenne, variance) et les mêmes poids de modèle. Vous pouvez immédiatement appeler predict, predict_proba ou score sans effectuer de nouvel ajustement.
import joblib
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
# Load the saved pipeline
loaded_pipe = joblib.load('/tmp/iris_pipeline.joblib')
# Predict and verify
predictions = loaded_pipe.predict(X[:5])
print('Predictions:', predictions)
print('Test accuracy:', loaded_pipe.score(X, y).round(4))Vérifier la fidélité aller-retour
Après le chargement, vérifiez que la chaîne de traitement chargée produit des prédictions identiques à celles de l’originale. Toute différence indique un problème de sérialisation ou une incompatibilité de versions. Une vérification simple consiste à comparer les prédictions élément par élément avec np.array_equal.
import joblib
import numpy as np
from sklearn.datasets import load_iris
X, _ = load_iris(return_X_y=True)
# Reload and compare
loaded = joblib.load('/tmp/iris_pipeline.joblib')
# Reload the original reference predictions
# (in practice, save original predictions before reload)
original_preds = loaded.predict(X) # use loaded as reference
loaded2 = joblib.load('/tmp/iris_pipeline.joblib')
reloaded_preds = loaded2.predict(X)
print('Predictions match:', np.array_equal(original_preds, reloaded_preds))Options de compression dans joblib
Les grandes chaînes de traitement (par exemple avec un RandomForest de 1 000 arbres) peuvent atteindre plusieurs centaines de MB. Utilisez joblib.dump(pipe, path, compress=3) pour compresser pendant l’enregistrement. Vous pouvez aussi spécifier explicitement le compresseur : compress=('zlib', 3) ou compress=('lz4', 1) pour une vitesse maximale. LZ4 est le plus rapide ; zlib produit des fichiers plus petits, mais est plus lent.
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import os
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)
# Uncompressed
joblib.dump(pipe, '/tmp/pipe_raw.joblib')
# Compressed
joblib.dump(pipe, '/tmp/pipe_compressed.joblib', compress=3)
print('Raw size:', os.path.getsize('/tmp/pipe_raw.joblib'), 'bytes')
print('Compressed size:', os.path.getsize('/tmp/pipe_compressed.joblib'), 'bytes')Utiliser pickle comme solution de remplacement
Si joblib n’est pas disponible, pickle fonctionne avec les chaînes de traitement sklearn. Utilisez le mode binaire ('rb'/'wb') lors de l’ouverture du fichier. Pour les petits modèles ou les outils ponctuels écrits sous forme de script, pickle convient parfaitement ; pour les systèmes de production qui traitent de grands tableaux NumPy, joblib est fortement recommandé.
import pickle
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)
# Save with pickle
with open('/tmp/model.pkl', 'wb') as f:
pickle.dump(pipe, f)
# Load with pickle
with open('/tmp/model.pkl', 'rb') as f:
loaded = pickle.load(f)
print('Loaded score:', loaded.score(X, y).round(4))Avertissements concernant la compatibilité des versions
Une question essentielle en production : une chaîne de traitement sérialisée avec scikit-learn 1.2 peut ne pas être chargée correctement avec scikit-learn 1.5. Notez toujours les versions des bibliothèques utilisées lors de l’entraînement dans un fichier de métadonnées placé à côté du modèle enregistré. Utilisez pip freeze > requirements.txt ou enregistrez les versions par programmation, puis stockez-les à côté du fichier du modèle.
import sklearn
import numpy as np
import json
import os
metadata = {
'sklearn_version': sklearn.__version__,
'numpy_version': np.__version__,
'model_file': 'iris_pipeline.joblib'
}
with open('/tmp/model_metadata.json', 'w') as f:
json.dump(metadata, f, indent=2)
print(json.dumps(metadata, indent=2))Charger une chaîne de traitement dans un script de production
Dans un service de production, le flux de travail est le suivant : charger la chaîne de traitement une seule fois au démarrage (et non à chaque requête), recevoir les caractéristiques d’entrée, les prétraiter avec les transformations intégrées à la chaîne de traitement, puis renvoyer les prédictions. Comme la chaîne de traitement inclut tout le prétraitement, le code du service n’a pas besoin de connaître la mise à l’échelle, l’encodage ou la PCA : tout cela est encapsulé dans l’objet enregistré.
import joblib
import numpy as np
# At startup (once)
model = joblib.load('/tmp/iris_pipeline.joblib')
def predict(sepal_length, sepal_width, petal_length, petal_width):
features = np.array([[sepal_length, sepal_width, petal_length, petal_width]])
label = model.predict(features)[0]
proba = model.predict_proba(features)[0]
return {'label': int(label), 'confidence': round(float(proba.max()), 4)}
result = predict(5.1, 3.5, 1.4, 0.2)
print('Prediction result:', result)Considérations de sécurité concernant les modèles pickle
Ne chargez jamais un fichier pickle provenant d’une source non fiable. Les fichiers pickle peuvent exécuter du code arbitraire lors de leur chargement : il s’agit d’une contrainte fondamentale de sécurité de Python. Pour partager des modèles à l’extérieur, envisagez des solutions plus sûres et propres à chaque format : ONNX pour la sérialisation entre frameworks, ou des fichiers joblib partagés uniquement au sein d’une infrastructure de confiance. Vérifiez toujours la somme de contrôle du fichier avant de le charger.
import hashlib
def file_sha256(path):
h = hashlib.sha256()
with open(path, 'rb') as f:
for chunk in iter(lambda: f.read(65536), b''):
h.update(chunk)
return h.hexdigest()
checksum = file_sha256('/tmp/iris_pipeline.joblib')
print('Model SHA-256:', checksum)
# In production: compare this checksum with the one stored in your model registryTest rapide de cohérence chargement-prédiction
Une dernière bonne pratique consiste à inclure dans votre paquet de modèle un court script de vérification qui charge la chaîne de traitement, exécute une entrée connue et vérifie que la sortie attendue est obtenue. Exécutez ce test dans votre chaîne CI/CD chaque fois que le modèle est promu en production, afin de confirmer que le fichier n’est pas corrompu et que l’environnement est compatible.
import joblib
import numpy as np
# Sanity test
model = joblib.load('/tmp/iris_pipeline.joblib')
# Known input (setosa): sepal_length=5.1, sepal_width=3.5, petal_length=1.4, petal_width=0.2
X_test = np.array([[5.1, 3.5, 1.4, 0.2]])
pred = model.predict(X_test)[0]
# Iris class 0 = setosa
assert pred == 0, f'Expected setosa (0) but got {pred}'
print('Sanity test PASSED — model predicts setosa correctly.')Vérification rapide
Vérifiez votre compréhension de l’enregistrement et du chargement des chaînes de traitement présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que joblib.dump et joblib.load enregistrent et restaurent une chaîne de traitement complète et ajustée, y compris tous ses paramètres de prétraitement, qu’il faut toujours enregistrer les versions des bibliothèques à côté du modèle enregistré pour garantir un chargement reproductible, et qu’il ne faut jamais charger de fichiers pickle provenant de sources non fiables, car ils peuvent exécuter du code arbitraire. Nous allons maintenant étudier les jeux de données déséquilibrés : détecter le déséquilibre entre les classes et comprendre pourquoi l’exactitude est une métrique trompeuse dans ce contexte.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Enregistrer et charger une chaîne de traitement avec joblib » est-elle gratuite ?
Oui — le texte complet de « Enregistrer et charger une chaîne de traitement avec joblib » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Enregistrer et charger une chaîne de traitement avec joblib » ?
Vous sérialiserez une chaîne de traitement ajustée sur le disque avec joblib.dump, puis la rechargerez dans une nouvelle session Python afin d’effectuer des prédictions sans nouvel entraînement. Tu pratiques Machine Learning Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Machine Learning Academy ?
Aucune expérience préalable n'est requise. Machine Learning Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Enregistrer et charger une chaîne de traitement avec joblib » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Machine Learning Academy ?
Oui. Chaque leçon Machine Learning Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Créer votre première chaîne de traitement : mise à l’échelle et classifieur
- ColumnTransformer dans une chaîne de traitement
- Valider et rechercher sur grille une chaîne de traitement complète
- Enregistrer et charger une chaîne de traitement avec joblib