Pour diffuser des prédictions à partir d'AI Platform Prediction, vous devez exporter votre modèle de machine learning entraîné sous la forme d'un ou plusieurs artefacts. Ce guide décrit les différentes manières d'exporter des modèles entraînés pour un déploiement sur AI Platform Prediction.
Les méthodes d'exportation de modèle suivantes s'appliquent quel que soit votre environnement d'entraînement, AI Platform Prediction ou autre, lorsque vous souhaitez déployer le modèle sur AI Platform Prediction pour diffuser les prédictions.
Une fois que vous avez exporté votre modèle, consultez le guide sur le déploiement des modèles pour apprendre à créer des ressources de modèle et de version sur AI Platform Prediction pour diffuser les prédictions.
Code personnalisé pour la prédiction
Si vous exportez un pipeline scikit-learn ou une routine de prédiction personnalisée, vous pouvez inclure le code personnalisé à exécuter au moment de la prédiction, en plus de la routine de prédiction fournie par votre framework de machine learning. Vous pouvez l'exploiter pour prétraiter les entrées de prédiction, post-traiter les résultats de la prédiction ou ajouter une journalisation personnalisée.
Taille maximale du modèle
La taille totale du fichier contenant les artefacts du modèle que vous déployez dans AI Platform Prediction doit être inférieure ou égale à 500 Mo si vous utilisez un ancien type de machine (MLS1). Elle doit être inférieure ou égale à 10 Go si vous utilisez un type de machine Compute Engine (N1). En savoir plus sur les types de machines pour la prédiction en ligne
Exporter un modèle Tensorflow SavedModel
Si vous utilisez TensorFlow pour entraîner un modèle, exportez-le en tant que répertoire TensorFlow SavedModel. Pour apprendre à exporter un modèle TensorFlow SavedModel que vous pouvez déployer sur AI Platform Prediction, consultez le guide sur l'exportation d'un modèle SavedModel pour la prédiction.
Si vous souhaitez déployer votre modèle TensorFlow dans une routine de prédiction personnalisée, vous pouvez l'exporter en tant que modèle SavedModel ou en tant qu'autre ensemble d'artefacts. Pour en savoir plus, consultez le guide sur les routines de prédiction personnalisées.
Exporter un optimiseur XGBoost
Si vous utilisez XGBoost pour entraîner un modèle, vous pouvez exporter le modèle entraîné à l'aide de l'une des trois méthodes suivantes :
- Utilisez la méthode
save_model
dexgboost.Booster
pour exporter un fichier nommémodel.bst
. - Utilisez
sklearn.externals.joblib
pour exporter un fichier nommémodel.joblib
. - Utilisez le module
pickle
de Python pour exporter un fichier nommémodel.pkl
.
Le nom de fichier de votre artefact de modèle doit correspondre exactement à l'une de ces options.
Les exemples à onglets suivants montrent comment entraîner et exporter un modèle avec chacune des trois méthodes :
xgboost.Booster
from sklearn import datasets
import xgboost as xgb
iris = datasets.load_iris()
dtrain = xgb.DMatrix(iris.data, label=iris.target)
bst = xgb.train({}, dtrain, 20)
bst.save_model('model.bst')
joblib
from sklearn import datasets
from sklearn.externals import joblib
import xgboost as xgb
iris = datasets.load_iris()
dtrain = xgb.DMatrix(iris.data, label=iris.target)
bst = xgb.train({}, dtrain, 20)
joblib.dump(bst, 'model.joblib')
pickle
import pickle
from sklearn import datasets
import xgboost as xgb
iris = datasets.load_iris()
dtrain = xgb.DMatrix(iris.data, label=iris.target)
bst = xgb.train({}, dtrain, 20)
with open('model.pkl', 'wb') as model_file:
pickle.dump(bst, model_file)
Exporter un Estimator scikit-learn
Si vous utilisez scikit-learn pour entraîner un modèle, vous pouvez l'exporter de l'une des deux manières suivantes :
- Utilisez
sklearn.externals.joblib
pour exporter un fichier nommémodel.joblib
. - Utilisez le module
pickle
de Python pour exporter un fichier nommémodel.pkl
.
Le nom de fichier de votre artefact de modèle doit correspondre exactement à l'une de ces options.
Les exemples à onglets suivants montrent comment entraîner et exporter un modèle avec chacune des deux méthodes :
joblib
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
iris = datasets.load_iris()
classifier = RandomForestClassifier()
classifier.fit(iris.data, iris.target)
joblib.dump(classifier, 'model.joblib')
pickle
import pickle
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
iris = datasets.load_iris()
classifier = RandomForestClassifier()
classifier.fit(iris.data, iris.target)
with open('model.pkl', 'wb') as model_file:
pickle.dump(classifier, model_file)
Exporter un pipeline scikit-learn
Le modèle scikit-learn Classe Pipeline peut vous aider à composer plusieurs Estimators. Par exemple, vous pouvez utiliser des transformateurs pour prétraiter les données et les transmettre après transformation à un classificateur. Vous pouvez exporter un pipeline de la même manière que les autres Estimators scikit-learn :
- Utilisez
sklearn.externals.joblib
pour exporter un fichier nommémodel.joblib
. - Utilisez le module
pickle
de Python pour exporter un fichier nommémodel.pkl
.
Le nom de fichier de votre artefact de modèle doit correspondre exactement à l'une de ces options.
Les exemples à onglets suivants montrent comment entraîner et exporter un modèle avec chacune des deux méthodes :
joblib
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import Pipeline
iris = datasets.load_iris()
pipeline = Pipeline([
('feature_selection', SelectKBest(chi2, k=2)),
('classification', RandomForestClassifier())
])
pipeline.fit(iris.data, iris.target)
joblib.dump(pipeline, 'model.joblib')
pickle
import pickle
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import Pipeline
iris = datasets.load_iris()
pipeline = Pipeline([
('feature_selection', SelectKBest(chi2, k=2)),
('classification', RandomForestClassifier())
])
pipeline.fit(iris.data, iris.target)
with open('model.pkl', 'wb') as model_file:
pickle.dump(pipeline, model_file)
Exporter le code de pipeline personnalisé
Si vous n'utilisez que des transformateurs issus du package sklearn
pour créer votre pipeline, il suffit d'exporter un seul artefact model.joblib
ou model.pkl
.
Votre déploiement AI Platform Prediction peut utiliser ces transformateurs au moment de la prédiction, car scikit-learn est inclus dans l'image de l'environnement d'exécution d'AI Platform Prediction.
Cependant, vous pouvez également utiliser les classes FunctionTransformer
ou TransformerMixin
de scikit-learn pour intégrer des transformations personnalisées. Dans ce cas, vous devez exporter
votre code personnalisé en tant que distribution source
package
afin de pouvoir les fournir à AI Platform Prediction.
L'exemple suivant montre comment utiliser du code personnalisé dans un pipeline et l'exporter pour AI Platform Prediction. Cet exemple utilise à la fois FunctionTransformer
et TransformerMixin
. La classe FunctionTransformer
est généralement plus pratique pour les transformations de base. Au contraire, TransformerMixin
vous permet de définir une transformation plus complexe qui enregistre l'état sérialisé lors de l'entraînement. Vous pouvez ensuite vous en servir pendant la prédiction.
Commencez par écrire le code suivant dans un fichier nommé my_module.py
:
import numpy as np
from sklearn.base import BaseEstimator
from sklearn.base import TransformerMixin
from sklearn.utils.validation import check_is_fitted
def add_sum(X):
sums = X.sum(1).reshape((-1,1))
transformed_X = np.append(X, sums, 1)
return transformed_X
class MySimpleScaler(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
self.means = np.mean(X, axis=0)
self.stds = np.std(X, axis=0)
if not self.stds.all():
raise ValueError('At least one column has standard deviation of 0.')
return self
def transform(self, X):
check_is_fitted(self, ('means', 'stds'))
transformed_X = (X - self.means) / self.stds
return transformed_X
Entraînez et exportez ensuite un pipeline à l'aide des transformations suivantes. Basculez entre les onglets ci-dessous pour afficher les deux manières d'exporter le pipeline :
joblib
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
import my_module
iris = datasets.load_iris()
pipeline = Pipeline([
('scale_data', my_module.MySimpleScaler()),
('add_sum_column', FunctionTransformer(my_module.add_sum)),
('classification', RandomForestClassifier())
])
pipeline.fit(iris.data, iris.target)
joblib.dump(pipeline, 'model.joblib')
pickle
import pickle
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
import my_module
iris = datasets.load_iris()
pipeline = Pipeline([
('scale_data', my_module.MySimpleScaler()),
('add_sum_column', FunctionTransformer(my_module.add_sum)),
('classification', RandomForestClassifier())
])
pipeline.fit(iris.data, iris.target)
with open('model.pkl', 'wb') as model_file:
pickle.dump(pipeline, model_file)
Enfin, créez un package de distribution source .tar.gz
contenant le fichier my_module
.
Pour ce faire, commencez par créer le fichier setup.py
suivant :
from setuptools import setup
setup(name='my_custom_code', version='0.1', scripts=['my_module.py'])
Exécutez ensuite python setup.py sdist --formats=gztar
dans votre interface système pour créer dist/my_custom_code-0.1.tar.gz
.
Consultez le guide sur le déploiement des modèles pour apprendre à déployer ce fichier tar avec votre fichier model.joblib
ou model.pkl
.
Notez que le fichier my_module.py
utilise NumPy et scikit-learn comme dépendances. Étant donné que
de ces bibliothèques sont incluses dans l'environnement d'exécution AI Platform Prediction
, il n'est pas nécessaire de les inclure dans
le fichier tar.
Pour accéder au tutoriel avancé sur l'utilisation du code de pipeline personnalisé, consultez la page Utiliser le code personnalisé des pipelines scikit-learn.
Exporter une routine de prédiction personnalisée
Pour une flexibilité maximale, créez et exportez une routine de prédiction personnalisée. Les routines de prédiction personnalisées vous permettent de fournir à AI Platform Prediction le code Python que vous souhaitez exécuter au moment de la prédiction, ainsi que tous les artefacts d'entraînement que vous souhaitez utiliser pendant la prédiction.
Consultez le guide sur les routines de prédiction personnalisées pour apprendre à les utiliser.
Étape suivante
- Apprenez à déployer votre modèle exporté sur AI Platform Prediction afin de diffuser des prédictions.
- Suivez un tutoriel pour apprendre à utiliser le code personnalisé des pipelines scikit-learn.
- Découvrez comment créer une routine de prédiction personnalisée.