Créer une routine de prédiction personnalisée avec Keras

Logo Colab Exécuter ce tutoriel sous forme de notebook dans Colab Logo GitHub Afficher le notebook sur GitHub

Ce tutoriel explique comment déployer un modèle Keras entraîné vers 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 une mise à l'échelle et pour post-traiter les données de sortie de prédiction en convertissant les données de sortie de probabilité softmax en chaînes d'étiquettes.

Le tutoriel vous guide à travers plusieurs étapes :

  • L'entraînement local d'un modèle Keras simple
  • 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

Découvrez les tarifs d'AI Platform Prediction et les tarifs de Cloud Storage, puis utilisez le simulateur de coût 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 environnement de développement Python fournit des instructions détaillées permettant de répondre à ces exigences. Les étapes suivantes présentent un condensé de ces instructions :

  1. Installez Python 3.

  2. Installez virtualenv et créez un environnement virtuel utilisant Python 3.

  3. Activez cet environnement.

  4. Effectuez les étapes de la section suivante pour installer le SDK Cloud.

Configurer un projet Google Cloud

  1. 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.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the AI Platform Training & Prediction and Compute Engine APIs.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init

  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  8. Make sure that billing is enabled for your Google Cloud project.

  9. Enable the AI Platform Training & Prediction and Compute Engine APIs.

    Enable the APIs

  10. Install the Google Cloud CLI.

  11. 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.

  1. Créez un compte de service :

    1. Dans la console Google Cloud, accédez à la page Créer un compte de service.

      Accéder à la page "Créer un compte de service"

    2. Dans le champ Nom du compte de service, saisissez un nom.
    3. Facultatif : Dans le champ Description du compte de service, saisissez une description.
    4. Cliquez sur Créer.
    5. Cliquez sur le champ Sélectionner un rôle. Sous Tous les rôles, sélectionnez AI Platform > Administrateur AI Platform.
    6. Cliquez sur Ajouter un autre rôle.

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

    8. 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.

  2. Créez une clé de compte de service pour l'authentification :

    1. Dans la console Google Cloud, cliquez sur l'adresse e-mail du compte de service que vous avez créé.
    2. Cliquez sur Keys (Clés).
    3. Cliquez sur AJOUTER UNE CLÉ -> Créer une clé.
    4. Cliquez sur Créer. Un fichier de clé JSON est téléchargé sur votre ordinateur.
    5. Cliquez sur Close (Fermer).

  3. 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 est disponible et créez 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 Keras

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 scikit-learn 'tensorflow=2.3'

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 associées à l'iris, puis formez un réseau de neurones simple à l'aide de Keras.

Enfin, exportez le modèle Keras entraîné en tant que fichier HDF5 (.h5) et exportez votre instance MySimpleScaler en tant que fichier pickle (.pkl) :

import pickle

from sklearn.datasets import load_iris
import tensorflow as tf

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
num_classes = len(iris.target_names)
X = scaler.preprocess(iris.data)
y = tf.keras.utils.to_categorical(iris.target, num_classes=num_classes)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(num_classes, activation=tf.nn.softmax))
model.compile(
  optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=1)

model.save('model.h5')
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
import tensorflow as tf

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)
    outputs = self._model.predict(preprocessed_inputs)
    if kwargs.get('probabilities'):
      return outputs.tolist()
    else:
      return [self._class_names[index] for index in np.argmax(outputs, axis=1)]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.h5')
    model = tf.keras.models.load_model(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 softmax du réseau de neurones (un tableau indiquant la probabilité que chaque étiquette soit celle appropriée) en étiquette avec la probabilité la plus élevée.

Toutefois, si le prédicteur reçoit un argument de mot-clé probabilities avec la valeur True, il renvoie le tableau de probabilité à la place. 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.h5 (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.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Déployer une routine de prédiction personnalisée

Créez une ressource de modèle et une ressource de version 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 2.3 \
  --python-version 3.7 \
  --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 à spécifier 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.0019204545533284545, 0.8623144626617432, 0.13576509058475494], [0.999488353729248, 0.000511515187099576, 1.293626752385535e-07]]

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