Sauvegarde et chargement des modèles Sklearn

En apprentissage automatique, le processus d'entraînement du modèle prend généralement du temps. Pour éviter de réentraîner le modèle à chaque fois, nous pouvons sauvegarder le modèle entraîné pour le charger et l'utiliser ultérieurement pour la prédiction.

scikit-learnIl existe deux méthodes courantes pour sauvegarder et charger des modèles :joblibetpickle。

1. Utilisation dejoblibSauvegarder et charger des modèles

joblibest un outil de sérialisation Python efficace, particulièrement adapté pour sauvegarder des objets contenant de grandes quantités de tableaux numériques (comme les tableaux numpy, les modèles scikit-learn, etc.). Comparé àpickle，joblibil est plus efficace lors du traitement de données à grande échelle.

joblib est une bibliothèque Python externe qui peut être installée avec la commande suivante :

pip install joblib

Sauvegarder le modèle

joblib fournit une API simple pour sauvegarder et charger des objets.

Nous pouvons utiliser la méthode joblib.dump() pour sauvegarder le modèle dans un fichier.

Exemple

import joblib
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

# Charger les données
data = load_iris()
X, y = data.data, data.target

# Diviser l'ensemble d'entraînement et l'ensemble de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer et entraîner le modèle
model = SVC(kernel='linear')
model.fit(X_train, y_train)

# Enregistrer le modèle dans un fichier
joblib.dump(model, 'svm_model.joblib')

Charger le modèle

Utilisez la méthode joblib.load() pour charger l'objet modèle enregistré.

Exemple

# Charger le modèle enregistré
loaded_model = joblib.load('svm_model.joblib')

# Utiliser le modèle chargé pour la prédiction
y_pred = loaded_model.predict(X_test)

# Afficher les résultats de prédiction
print("Predictions:", y_pred)

Grâce aux étapes ci-dessus, nous avons réussi à enregistrer le modèle entraîné dans un fichier et pouvons charger le modèle et faire des prédictions à tout moment ultérieur.

2. Utilisation de pickle pour enregistrer et charger des modèles

pickle est un module Python intégré qui permet de sérialiser et de désérialiser des objets Python.

Bien que joblib soit plus adapté à la manipulation de grandes quantités de données, pickle est également un outil courant pour enregistrer et charger des modèles, adapté aux cas généraux.

Sauvegarder le modèle

Comme joblib, pickle dispose également d'une API simple pour enregistrer et charger des objets.

Le code pour enregistrer le modèle est le suivant :

Exemple

import pickle
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

# Charger les données
data = load_iris()
X, y = data.data, data.target

# Diviser l'ensemble d'entraînement et l'ensemble de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer et entraîner le modèle
model = SVC(kernel='linear')
model.fit(X_train, y_train)

# Enregistrer le modèle avec pickle
with open('svm_model.pkl', 'wb') as f:
    pickle.dump(model, f)

Charger le modèle

Utilisez pickle.load() pour charger le modèle :

Exemple

# Utiliser pickle pour charger le modèle enregistré
with open('svm_model.pkl', 'rb') as f:
    loaded_model = pickle.load(f)

# Utiliser le modèle chargé pour la prédiction
y_pred = loaded_model.predict(X_test)

# Afficher les résultats de prédiction
print("Predictions:", y_pred)

3、joblib vs pickle

joblib et pickle sont deux méthodes courantes pour enregistrer et charger des modèles.

joblib est plus adapté pour enregistrer de grands objets de données, tandis que pickle est l'outil de sérialisation standard de Python, adapté aux cas généraux.

  • joblib: Généralement adapté pour enregistrer des objets contenant de grandes quantités de données numériques (comme les tableaux numpy).joblibLors du traitement de données à grande échelle, il est plus efficace quepickleplus efficace.
  • pickle: Convient pour enregistrer des objets plus petits ou des objets Python standard. C'est une bibliothèque Python intégrée et elle ne nécessite aucune installation supplémentaire.

Si le modèle contient un grand nombre de tableaux numériques ou de matrices (comme les machines à vecteurs de support, les forêts aléatoires, etc.), joblib est recommandé car il est plus efficace que pickle. Pour les modèles plus petits ou les modèles qui ne contiennent pas de grandes quantités de données numériques, pickle suffit.

4. Enregistrer et charger un Pipeline

Dans les applications pratiques, un modèle n'est pas seulement un modèle unique ; il combine parfois plusieurs étapes de traitement (telles que le prétraitement des données, la sélection de caractéristiques, l'entraînement du modèle, etc.). Ces étapes de traitement peuvent être réalisées à l'aide du Pipeline de scikit-learn. Le Pipeline peut également être enregistré et chargé à l'aide de joblib ou pickle.

Enregistrer le Pipeline :

Exemple

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
import joblib

# Créer un pipeline
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svc', SVC(kernel='linear'))
])

# Entraîner le pipeline
pipeline.fit(X_train, y_train)

# Enregistrer le pipeline dans un fichier
joblib.dump(pipeline, 'pipeline_model.joblib')

Charger le Pipeline :

Exemple

# Charger le pipeline
loaded_pipeline = joblib.load('pipeline_model.joblib')

# Utiliser le pipeline chargé pour la prédiction
y_pred = loaded_pipeline.predict(X_test)

# Afficher les résultats de prédiction
print("Predictions:", y_pred)

Le processus de sauvegarde et de chargement d'un pipeline est le même que celui d'un modèle unique ; il vous suffit de vous assurer que l'ensemble de l'objet pipeline est sauvegardé et chargé.

5. Gestion des versions de modèle

Dans les applications réelles d'apprentissage automatique, les mises à jour de modèle et la gestion des versions sont cruciales. Chaque fois que vous entraînez et enregistrez un modèle, il est préférable d'ajouter un horodatage ou un numéro de version au nom du fichier de modèle afin de distinguer les différentes versions du modèle. Par exemple :

Exemple

import time

# Créer un horodatage
timestamp = time.strftime("%Y%m%d-%H%M%S")

# Enregistrer le modèle avec un horodatage
joblib.dump(model, f'svm_model_{timestamp}.joblib')

De cette façon, nous pouvons gérer différentes versions de modèles en fonction des horodatages, ce qui facilite le retour en arrière et la mise à jour des modèles.

6. Utilisation du modèle pour la persistance

Une fois le modèle entraîné et sauvegardé, nous pouvons le charger dans des applications pratiques ultérieures pour effectuer des prédictions sans réentraînement.

Par exemple, nous pouvons intégrer le modèle sauvegardé avec des services web, des tâches par lots ou d'autres applications, afin que le modèle puisse être réutilisé sans réentraînement.

Utilisation de modèles chargés dans des services web

Par exemple, supposons que nous utilisions Flask pour créer un service web simple qui fournit des services de prédiction de modèle via une API. Dans ce cas, nous pouvons charger le modèle sauvegardé pour une prédiction en temps réel.

Exemple

from flask import Flask, request, jsonify
import joblib
import numpy as np

app = Flask(__name__)

# Charger le modèle
model = joblib.load('svm_model.joblib')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()  # Obtenir les données d'entrée
    features = np.array(data['features']).reshape(1, -1)  # Convertir en un format adapté à la prédiction
    prediction = model.predict(features)  # Utiliser le modèle chargé pour la prédiction
    return jsonify({'prediction': prediction.tolist()})  # Retourner le résultat de la prédiction

if __name__ == '__main__':
    app.run(debug=True)
Autres extensions