Exporter des modèles pour les prédictions

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 de xgboost.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

La classe Pipeline scikit-learn 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 package de distribution source afin de pouvoir le 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 simples. 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 package tarball à l'aide d'un fichier model.joblib ou model.pkl.

Notez que le fichier my_module.py utilise NumPy et scikit-learn comme dépendances. Étant donné que ces deux bibliothèques sont incluses dans l'image de l'environnement d'exécution d'AI Platform Prediction, il n'est pas nécessaire de les ajouter au package tarball.

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