 Exécuter ce tutoriel sous forme de notebook dans Colab |
 Afficher le notebook sur GitHub |
Présentation
Ce tutoriel explique comment déployer un modèle scikit-learn entraîné sur AI Platform Prediction et comment diffuser des prédictions à l'aide d'une routine de prédiction personnalisée. Il vous permet de personnaliser la manière dont AI Platform Prediction répond à chaque requête de prédiction.
Dans cet exemple, vous allez utiliser une routine de prédiction personnalisée pour prétraiter les données d'entrée de prédiction en leur appliquant un scaling et pour post-traiter les données de sortie de prédiction en convertissant les numéros de classe en chaînes d'étiquettes.
Le tutoriel vous guide à travers plusieurs étapes :
- L'entraînement local d'un modèle scikit-learn simple (dans ce notebook)
- La création et le déploiement d'une routine de prédiction personnalisée vers AI Platform Prediction
- La diffusion des requêtes de prédiction issues de ce déploiement
Ensemble de données
Ce tutoriel utilise l'ensemble de données nommé Iris de Fisher, un petit ensemble de données très apprécié dans l'expérimentation de techniques de machine learning. Chaque instance possède quatre caractéristiques numériques, qui représentent différentes mesures d'une fleur, et une étiquette cible qui lui attribue l'un des trois types d'iris : Iris setosa, Iris versicolour ou Iris virginica.
Ce tutoriel utilise la copie de l'ensemble de données Iris incluse dans la bibliothèque scikit-learn.
Objectif
L'objectif est d'entraîner un modèle exploitant les mesures d'une fleur en tant que données d'entrée pour prédire de quel type d'iris il s'agit.
Ce tutoriel porte davantage sur l'utilisation de ce modèle avec AI Platform Prediction que sur la conception du modèle.
Coûts
Ce tutoriel utilise des composants facturables de Google Cloud :
- AI Platform Prediction
- Cloud Storage
En savoir plus sur AI Platform Prediction tarifs et Cloud Storage les tarifs, et utilisez la colonne Tarification Calculatrice pour générer une estimation des coûts en fonction de votre utilisation prévue.
Avant de commencer
Vous devez effectuer plusieurs opérations avant de pouvoir entraîner et déployer un modèle dans AI Platform Prediction :
- Configurer l'environnement de développement local
- Configurer un projet Google Cloud avec la facturation et les API nécessaires activées
- Créer un bucket Cloud Storage pour stocker le package d'entraînement et le modèle entraîné
Configurer l'environnement de développement local
Pour suivre ce tutoriel, vous avez besoin des éléments suivants :
- Python 3
- virtualenv
- Le SDK Google Cloud
Le guide Google Cloud Configurer un projet de développement Python environnement fournit des instructions détaillées pour répondre à ces exigences. Les étapes suivantes présentent un condensé de ces instructions :
Installer virtualenv et créer un environnement virtuel utilisant Python 3.
Activez cet environnement.
Effectuez les étapes de la section suivante pour installer le SDK Cloud.
Configurer un projet Google Cloud
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the AI Platform Training & Prediction and Compute Engine APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init -
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the AI Platform Training & Prediction and Compute Engine APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
Authentifier le compte GCP
Pour configurer l'authentification, vous devez créer une clé de compte de service et définir une variable d'environnement pour le chemin d'accès à la clé de compte de service.
-
Créez un compte de service :
-
Dans la console Google Cloud, accédez à la page Créer un compte de service.
- Dans le champ Nom du compte de service, saisissez un nom.
- Facultatif : Dans le champ Description du compte de service, saisissez une description.
- Cliquez sur Créer.
- Cliquez sur le champ Sélectionner un rôle. Sous Tous les rôles, sélectionnez AI Platform > Administrateur AI Platform.
- Cliquez sur Ajouter un autre rôle.
-
Cliquez sur le champ Sélectionner un rôle. Sous Tous les rôles, sélectionnez Stockage > Administrateur des objets de l'espace de stockage.
-
Cliquez sur Terminé pour créer le compte de service.
Ne fermez pas la fenêtre de votre navigateur. Vous en aurez besoin lors de la tâche suivante.
-
-
Créez une clé de compte de service pour l'authentification :
- Dans la console Google Cloud, cliquez sur l'adresse e-mail du compte de service que vous avez créé.
- Cliquez sur Keys (Clés).
- Cliquez sur AJOUTER UNE CLÉ -> Créer une clé.
- Cliquez sur Créer. Un fichier de clé JSON est téléchargé sur votre ordinateur.
- Cliquez sur Close (Fermer).
-
Définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS de façon à pointer vers le chemin du fichier JSON contenant la clé de votre compte de service. Cette variable ne s'applique qu'à la session d'interface système actuelle. Par conséquent, si vous ouvrez une nouvelle session, vous devez la définir à nouveau.
Créer un bucket Cloud Storage
Pour déployer une routine de prédiction personnalisée, vous devez importer les artefacts du modèle entraîné, ainsi que votre code personnalisé vers Cloud Storage.
Définissez le nom du bucket Cloud Storage en tant que variable d'environnement. Ce nom doit être unique dans tous les buckets Cloud Storage :
BUCKET_NAME="your-bucket-name"
Sélectionnez une région dans laquelle AI Platform Prediction disponibles et créer une autre variable d'environnement.
REGION="us-central1"
Créez le bucket Cloud Storage dans cette région, puis utilisez cette même région pour l'entraînement et les prédictions. Exécutez la commande suivante pour créer le bucket s'il n'existe pas déjà :
gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION
Créer et entraîner un modèle scikit-learn
Il est souvent impossible d'utiliser vos données sous leur forme brute pour entraîner un modèle de machine learning. Même quand c'est possible, le prétraitement des données avant de les utiliser pour l'entraînement peut parfois améliorer votre modèle.
Si vous souhaitez que les données de saisie de prédiction aient le même format que vos données d'entraînement, vous devez effectuer un prétraitement identique lors des opérations d'entraînement et de prédiction pour vous assurer que votre modèle réalise des prédictions cohérentes.
Dans cette section, vous allez créer un module de prétraitement et l'utiliser dans le cadre de l'entraînement. Vous exporterez ensuite un préprocesseur avec les caractéristiques apprises lors de l'entraînement pour une utilisation ultérieure avec votre routine de prédiction personnalisée.
Installer des dépendances pour un entraînement en local
L'entraînement local nécessite plusieurs dépendances :
pip install numpy>=1.16.0 scikit-learn==0.20.2
Rédiger le préprocesseur
Vous pouvez améliorer votre modèle en effectuant un scaling des données d'entraînement de sorte que chaque colonne de caractéristiques numériques représente une moyenne de 0 et un écart-type de 1.
Créez preprocess.py, qui contient une classe permettant d'effectuer ce scaling :
import numpy as np
class MySimpleScaler(object):
def __init__(self):
self._means = None
self._stds = None
def preprocess(self, data):
if self._means is None: # during training only
self._means = np.mean(data, axis=0)
if self._stds is None: # during training only
self._stds = np.std(data, axis=0)
if not self._stds.all():
raise ValueError('At least one column has standard deviation of 0.')
return (data - self._means) / self._stds
Notez qu'une instance de MySimpleScaler enregistre les moyennes et les écarts-types de chaque colonne de caractéristiques lors de la première utilisation. Elle utilise ensuite ces statistiques récapitulatives pour effectuer le scaling des données qu'elle rencontre par la suite.
Ainsi, vous pouvez stocker les caractéristiques issues de la distribution de l'entraînement et les utiliser pour un prétraitement identique au moment de la prédiction.
Entraîner le modèle
Ensuite, utilisez preprocess.MySimpleScaler pour prétraiter les données relatives à l'iris, puis pour entraîner un modèle à l'aide de scikit-learn.
Enfin, exportez le modèle entraîné en tant que fichier joblib (.joblib) et exportez votre instance MySimpleScaler en tant que fichier pickle (.pkl) :
import pickle
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
from preprocess import MySimpleScaler
iris = load_iris()
scaler = MySimpleScaler()
X = scaler.preprocess(iris.data)
y = iris.target
model = RandomForestClassifier()
model.fit(X, y)
joblib.dump(model, 'model.joblib')
with open ('preprocessor.pkl', 'wb') as f:
pickle.dump(scaler, f)
Déployer une routine de prédiction personnalisée
Pour déployer une routine de prédiction personnalisée afin de diffuser les prédictions à partir de votre modèle entraîné, procédez comme suit :
- Créez un prédicteur personnalisé pour gérer les requêtes
- Empaquetez votre prédicteur et votre module de prétraitement.
- Téléchargez vos artefacts de modèle et votre code personnalisé sur Cloud Storage
- Déployez votre routine de prédiction personnalisée dans AI Platform Prediction.
Créer un prédicteur personnalisé
Pour déployer une routine de prédiction personnalisée, vous devez créer une classe qui met en œuvre l'interface du prédicteur. Cela indique à AI Platform Prediction comment charger votre modèle et comment gérer les requêtes de prédiction.
Écrivez le code suivant dans predictor.py :
import os
import pickle
import numpy as np
from sklearn.datasets import load_iris
from sklearn.externals import joblib
class MyPredictor(object):
def __init__(self, model, preprocessor):
self._model = model
self._preprocessor = preprocessor
self._class_names = load_iris().target_names
def predict(self, instances, **kwargs):
inputs = np.asarray(instances)
preprocessed_inputs = self._preprocessor.preprocess(inputs)
if kwargs.get('probabilities'):
probabilities = self._model.predict_proba(preprocessed_inputs)
return probabilities.tolist()
else:
outputs = self._model.predict(preprocessed_inputs)
return [self._class_names[class_num] for class_num in outputs]
@classmethod
def from_path(cls, model_dir):
model_path = os.path.join(model_dir, 'model.joblib')
model = joblib.load(model_path)
preprocessor_path = os.path.join(model_dir, 'preprocessor.pkl')
with open(preprocessor_path, 'rb') as f:
preprocessor = pickle.load(f)
return cls(model, preprocessor)
Sachez qu'en plus d'utiliser le préprocesseur que vous avez défini lors de l'entraînement, ce prédicteur effectue une étape de post-traitement qui convertit les données de sortie de prédiction issues des index de classe (0, 1 ou 2) en chaînes d'étiquettes (nom du type de fleur).
Toutefois, si le prédicteur reçoit un argument de mot-clé probabilities avec la valeur True, il renvoie un tableau de probabilité à la place, indiquant la probabilité que chacune des trois classes représente l'étiquette appropriée (selon le modèle).
La dernière partie de ce tutoriel montre comment fournir cet argument de mot clé.
Empaqueter le code personnalisé
Vous devez empaqueter predictor.py et preprocess.py en tant que package de distribution source .tar.gz et le transmettre à AI Platform Prediction, qui pourra utiliser votre code personnalisé pour diffuser des prédictions.
Écrivez le code setup.py suivant pour définir votre package :
from setuptools import setup
setup(
name='my_custom_code',
version='0.1',
scripts=['predictor.py', 'preprocess.py'])
Exécutez ensuite la commande suivante pour créer dist/my_custom_code-0.1.tar.gz :
python setup.py sdist --formats=gztar
Importer des artefacts de modèle et du code personnalisé vers Cloud Storage
Avant de pouvoir déployer votre modèle pour la diffusion, AI Platform Prediction doit avoir accès aux fichiers suivants dans Cloud Storage :
model.joblib(artefact de modèle)preprocessor.pkl(artefact de modèle)my_custom_code-0.1.tar.gz(code personnalisé)
Les artefacts de modèle doivent être stockés ensemble dans un répertoire de modèle auquel votre prédicteur peut accéder en tant qu'argument model_dir dans sa méthode de classe from_path.
Le code personnalisé ne doit pas nécessairement se trouver dans le même répertoire. Exécutez les commandes suivantes pour importer vos fichiers :
gcloud storage cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gcloud storage cp model.joblib preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/
Déployer une routine de prédiction personnalisée
Créer une ressource de modèle et une version ressource pour déployer votre routine de prédiction personnalisée. Commencez par définir les variables d'environnement avec vos noms de ressources :
MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'
Puis, créez votre modèle :
gcloud ai-platform models create $MODEL_NAME \
--regions $REGION
Ensuite, créez une version. Lors de cette étape, vous allez indiquer les chemins d'accès aux artefacts et au code personnalisé que vous avez importés dans Cloud Storage :
gcloud components install beta
gcloud beta ai-platform versions create $VERSION_NAME \
--model $MODEL_NAME \
--runtime-version 1.13 \
--python-version 3.5 \
--origin gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/ \
--package-uris gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz \
--prediction-class predictor.MyPredictor
En savoir plus sur les options à inclure préciser lorsque vous déployez une routine de prédiction personnalisée.
Diffuser des prédictions en ligne
Testez votre déploiement en envoyant une requête de prédiction en ligne. Commencez par installer la bibliothèque cliente des API Google pour Python :
pip install --upgrade google-api-python-client
Envoyez ensuite deux instances issues des données Iris à votre version déployée en exécutant le code Python suivant :
import googleapiclient.discovery
instances = [
[6.7, 3.1, 4.7, 1.5],
[4.6, 3.1, 1.5, 0.2],
]
service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}/versions/{}'.format(PROJECT_ID, MODEL_NAME, VERSION_NAME)
response = service.projects().predict(
name=name,
body={'instances': instances}
).execute()
if 'error' in response:
raise RuntimeError(response['error'])
else:
print(response['predictions'])
['versicolor', 'setosa']
Envoyer des arguments de mot clé
Lorsque vous envoyez une requête de prédiction à une routine de prédiction personnalisée, vous pouvez fournir des champs supplémentaires dans le corps de votre requête.
La méthode predict du prédicteur les reçoit en tant que champs du dictionnaire **kwargs.
Le code suivant envoie la même requête qu'auparavant, mais avec un champ probabilities supplémentaire dans le corps de la requête :
response = service.projects().predict(
name=name,
body={'instances': instances, 'probabilities': True}
).execute()
if 'error' in response:
raise RuntimeError(response['error'])
else:
print(response['predictions'])
[[0.0, 1.0, 0.0], [1.0, 0.0, 0.0]]
Nettoyer
Pour nettoyer toutes les ressources GCP utilisées dans ce projet, vous pouvez supprimer le projet GCP que vous avez utilisé pour le tutoriel.
Vous pouvez également nettoyer des ressources individuelles en exécutant les commandes suivantes :
# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --quiet --model $MODEL_NAME
# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet
# Delete Cloud Storage objects that were created
gcloud storage rm gs://$BUCKET_NAME/custom_prediction_routine_tutorial --recursive
Étapes suivantes
- Découvrez plus d'informations sur les routines de prédiction personnalisées.
- Découvrez comment exporter un modèle. pour inférer des prédictions sans routine de prédiction personnalisée.