Cette ancienne version d'AI Platform Prediction est obsolète et ne sera plus disponible sur Google Cloud après le 31 janvier 2025. Tous les modèles, les métadonnées associées et les déploiements seront supprimés après le 31 janvier 2025. Migrez vos ressources vers Vertex AI pour obtenir de nouvelles fonctionnalités de machine learning qui ne sont pas disponibles dans AI Platform.

Cette page a été traduite par l'API Cloud Translation.

Obtenir des prédictions en ligne avec scikit-learn

Cet exemple entraîne un modèle à prédire le niveau de revenu d'une personne en fonction de l'ensemble de données sur le revenu collectées par recensement. Après avoir entraîné et enregistré le modèle localement, vous allez le déployer dans AI Platform Prediction et l'interroger pour obtenir des prédictions en ligne.

Vous pouvez déployer et diffuser des pipelines scikit-learn sur AI Platform Prediction. Le module Pipeline de scikit-learn vous permet d'appliquer plusieurs transformations de données avant l'entraînement avec un Estimator. Cette opération comprend plusieurs étapes de traitement des données, et garantit que les mêmes données d'apprentissage sont utilisées à chaque étape.

Ce tutoriel est également disponible sur GitHub sous forme de notebook Jupyter.

Intégrer le modèle à AI Platform Prediction

Vous pouvez intégrer votre modèle à AI Platform Prediction pour obtenir des prédictions en cinq étapes :

Enregistrer le modèle dans un fichier
Transférer le modèle enregistré dans Cloud Storage
Créer une ressource de modèle sur AI Platform Prediction
Créer une version du modèle en associant le modèle enregistré
Effectuer une prédiction en ligne

Avant de commencer

Suivez les étapes ci-dessous pour configurer un compte GCP, activer l'API AI Platform Prediction, puis installer et activer le SDK Cloud.

Configurer le projet GCP

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.

Go to project selector

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

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

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

Go to project selector

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

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

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Configurer votre environnement

Choisissez l'une des options ci-dessous pour configurer votre environnement en local sous macOS ou dans un environnement à distance sur Cloud Shell.

Pour les utilisateurs de macOS, nous vous recommandons de configurer votre environnement à l'aide de l'onglet macOS ci-dessous. Cloud Shell est disponible sous macOS, Linux et Windows (voir l'onglet Cloud Shell). Ce service vous permet d'essayer AI Platform Prediction rapidement. Toutefois, son utilisation n'est pas adaptée aux tâches de développement continu.

macOS

Vérifiez que Python est installé
Si ce n'est pas le cas, installez Python.
```
python -V
```
Vérifiez que pip est installé
pip est le gestionnaire de packages de Python, inclus dans les versions actuelles de Python. Vérifiez que pip est déjà installé en exécutant la commande pip --version. Si ce n'est pas le cas, découvrez comment installer pip.

Vous pouvez mettre à jour pip à l'aide de la commande suivante :
```
pip install -U pip
```
Pour en savoir plus, consultez la documentation sur pip.
Installez virtualenv
virtualenv est un outil permettant de créer des environnements Python isolés. Vérifiez que virtualenv est déjà installé en exécutant la commande virtualenv --version. Si ce n'est pas le cas, installez virtualenv :
```
pip install --user --upgrade virtualenv
```
Dans ce guide, pour créer un environnement de développement isolé, créez un environnement virtuel dans virtualenv. Par exemple, la commande suivante active un environnement nommé aip-env :
```
virtualenv aip-env
source aip-env/bin/activate
```
Pour les besoins de ce tutoriel, exécutez toutes les autres commandes dans votre environnement virtuel.
Obtenez plus d'informations sur l'utilisation de virtualenv. Pour quitter virtualenv, exécutez la commande deactivate.

Cloud Shell

Ouvrez Google Cloud Console.

Google Cloud Console
Cliquez sur le bouton Activer Google Cloud Shell en haut de la fenêtre de la console.

Une session Cloud Shell s'ouvre dans un nouveau cadre en bas de la console et affiche une invite de ligne de commande. L'initialisation de la session Shell peut prendre quelques secondes.

Votre session Cloud Shell est prête à l'emploi.
Configurez l'outil de ligne de commande gcloud pour qu'il utilise le projet sélectionné.
```
gcloud config set project [selected-project-id]
```
où [selected-project-id] correspond à votre ID de projet. (Saisissez-le sans les crochets.)

Installer des frameworks

macOS

Dans votre environnement virtuel, exécutez la commande suivante pour installer les versions de scikit-learn et pandas utilisées dans la version d'exécution 2.11 d'AI Platform Prediction :

(aip-env)$ pip install scikit-learn==1.0.2 pandas==1.3.5

En spécifiant les numéros de version dans la commande précédente, vous vous assurez que les dépendances de votre environnement virtuel correspondent à celles de la version d'exécution. Vous évitez ainsi tout comportement inattendu lors de l'exécution de votre code sur AI Platform Prediction.

Pour plus d'informations, y compris sur les options d'installation et les opérations de dépannage, reportez-vous aux instructions d'installation de chaque framework :

Cloud Shell

Exécutez la commande suivante pour installer scikit-learn et pandas :

pip install --user scikit-learn pandas

Pour plus d'informations, y compris sur les options d'installation et les opérations de dépannage, reportez-vous aux instructions d'installation de chaque framework :

Télécharger les données

L'ensemble de données sur les revenus collectées par recensement que cet exemple utilise pour l'entraînement est hébergée par UC Irvine Machine Learning Repository (dépôt de machine learning de l'Université de Californie à Irvine). Pour en savoir plus, consultez la section À propos des données.

Le fichier d'entraînement est adult.data.
Le fichier d'évaluation est adult.test.

Entraîner et enregistrer un modèle

Pour entraîner et enregistrer un modèle, procédez comme suit :

Chargez les données dans un objet DataFrame pandas pour pouvoir les utiliser avec scikit-learn.
Entraînez un modèle simple dans scikit-learn.
Enregistrez le modèle dans un fichier pouvant être importé sur AI Platform Prediction.

Si vous disposez déjà d'un modèle entraîné à transférer, découvrez comment exporter le modèle.

Charger et transformer des données

Vous pouvez exporter des objets Pipeline à l'aide de la version de joblib incluse dans scikit-learn ou depickle, de la même manière que vous exportez des Estimators scikit-learn. L'exemple suivant utilise des pipelines pour convertir des caractéristiques catégoriques individuelles en valeurs numériques, puis combine ces caractéristiques et entraîne le modèle à l'aide de RandomForestClassifier.

Remarque : Pour exporter un artefact de modèle joblib compatible avec AI Platform Prediction, vous devez utiliser la version de joblib distribuée avec scikit-learn et non la version autonome. Pour importer cette bibliothèque en Python, utilisez l'instruction from sklearn.externals import joblib.

from sklearn.externals import joblib
import json
import numpy as np
import os
import pandas as pd
import pickle
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import LabelBinarizer

# Define the format of your input data, including unused columns.
# These are the columns from the census data files.
COLUMNS = (
    'age',
    'workclass',
    'fnlwgt',
    'education',
    'education-num',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'capital-gain',
    'capital-loss',
    'hours-per-week',
    'native-country',
    'income-level'
)

# Categorical columns are columns that need to be turned into a numerical value to be used by scikit-learn
CATEGORICAL_COLUMNS = (
    'workclass',
    'education',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'native-country'
)


# Load the training census dataset
with open('./census_data/adult.data', 'r') as train_data:
    raw_training_data = pd.read_csv(train_data, header=None, names=COLUMNS)

# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = raw_training_data.drop('income-level', axis=1).as_matrix().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = (raw_training_data['income-level'] == ' >50K').as_matrix().tolist()


# Load the test census dataset
with open('./census_data/adult.test', 'r') as test_data:
    raw_testing_data = pd.read_csv(test_data, names=COLUMNS, skiprows=1)
# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
test_features = raw_testing_data.drop('income-level', axis=1).as_matrix().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
test_labels = (raw_testing_data['income-level'] == ' >50K.').as_matrix().tolist()


# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS[:-1]):
    if col in CATEGORICAL_COLUMNS:
        # Create a scores array to get the individual categorical column.
        # Example:
        #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
        #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
        #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        #
        # Returns: [['Sate-gov']]
        scores = []
        # Build the scores array
        for j in range(len(COLUMNS[:-1])):
            if i == j: # This column is the categorical column we want to extract.
                scores.append(1) # Set to 1 to select this column
            else: # Every other column should be ignored.
                scores.append(0)
        skb = SelectKBest(k=1)
        skb.scores_ = scores
        # Convert the categorical column to a numerical value
        lbn = LabelBinarizer()
        r = skb.transform(train_features)
        lbn.fit(r)
        # Create the pipeline to extract the categorical feature
        categorical_pipelines.append(
            ('categorical-{}'.format(i), Pipeline([
                ('SKB-{}'.format(i), skb),
                ('LBN-{}'.format(i), lbn)])))

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(('numerical', skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([
    ('union', preprocess),
    ('classifier', classifier)
])

Exporter le modèle

Pour exporter votre modèle, vous pouvez utiliser joblib ou la bibliothèque pickle de Python :

joblib

from sklearn.externals import joblib

# Export the model to a file
joblib.dump(pipeline, 'model.joblib')

pickle

# Export the model to a file
with open('model.pkl', 'wb') as model_file:
  pickle.dump(pipeline, model_file)

Règles de dénomination des fichiers de modèle

Le fichier de modèle enregistré que vous importez dans Cloud Storage doit être nommé model.pkl ou model.joblib, selon la bibliothèque utilisée. Cette restriction garantit que, lors de l'importation, AI Platform Prediction reconstruit le modèle à l'aide du même schéma que celui utilisé lors de l'exportation.

Bibliothèque utilisée pour exporter le modèle	Nom de modèle correct
`pickle`	`model.pkl`
`sklearn.externals.joblib`	`model.joblib`

Pour les futures itérations de votre modèle, organisez votre bucket Cloud Storage de sorte que chaque nouveau modèle dispose d'un répertoire dédié.

Stocker le modèle dans Cloud Storage

Dans ce tutoriel, la procédure la plus simple consiste à utiliser un bucket Cloud Storage dédié dans le même projet que pour AI Platform Prediction.

Si vous utilisez un bucket dans un autre projet, vous devez vous assurer que votre compte de service AI Platform Prediction peut accéder à votre modèle dans Cloud Storage. Sans les autorisations appropriées, votre requête de création d'une version de modèle AI Platform Prediction ne peut pas aboutir. En savoir plus sur l'octroi d'autorisations relatives au stockage.

Configurer un bucket Cloud Storage

Vous trouverez dans cette section la procédure à suivre pour créer un bucket. Vous pouvez utiliser un bucket existant, mais il doit se trouver dans la même région que celle où vous prévoyez d'exécuter des tâches AI Platform. En outre, s'il ne fait pas partie du projet que vous utilisez pour exécuter AI Platform Prediction, vous devez accorder l'accès aux comptes de service AI Platform Prediction.

Indiquez un nom pour votre nouveau bucket. Ce nom doit être unique par rapport à tous les buckets dans Cloud Storage.
```
BUCKET_NAME="YOUR_BUCKET_NAME"
```
Par exemple, vous pouvez utiliser le nom de votre projet en ajoutant -aiplatform :
```
PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform
```
Vérifiez le nom du bucket que vous avez créé.
```
echo $BUCKET_NAME
```
Sélectionnez une région pour votre bucket, puis définissez une variable d'environnement REGION.

Utilisez la même région que celle où vous prévoyez d'exécuter des tâches AI Platform Prediction. Consultez la liste des régions disponibles pour les services AI Platform Prediction.

Par exemple, le code suivant crée la variable REGION et la définit sur us-central1 :
```
REGION=us-central1
```

Créez le bucket :

gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Importer le fichier de modèle exporté dans Cloud Storage

Exécutez la commande suivante pour transférer le fichier de modèle enregistré dans votre bucket dans Cloud Storage :

gcloud storage cp ./model.joblib gs://your_bucket_name/model.joblib

Mettre en forme les données pour la prédiction

Avant d'envoyer une requête de prédiction en ligne, vous devez mettre en forme les données de test pour que le service de prédiction d'AI Platform Prediction puisse les utiliser. Assurez-vous que le format des instances d'entrée correspond au format attendu par le modèle.

gcloud

Créez un fichier input.json en plaçant chaque instance de données d'entrée sur une ligne séparée. L'exemple suivant utilise les dix premières instances de données de la liste test_features définie lors des étapes précédentes.

    [25, "Private", 226802, "11th", 7, "Never-married", "Machine-op-inspct", "Own-child", "Black", "Male", 0, 0, 40, "United-States"]
    [38, "Private", 89814, "HS-grad", 9, "Married-civ-spouse", "Farming-fishing", "Husband", "White", "Male", 0, 0, 50, "United-States"]
    [28, "Local-gov", 336951, "Assoc-acdm", 12, "Married-civ-spouse", "Protective-serv", "Husband", "White", "Male", 0, 0, 40, "United-States"]
    [44, "Private", 160323, "Some-college", 10, "Married-civ-spouse", "Machine-op-inspct", "Husband", "Black", "Male", 7688, 0, 40, "United-States"]
    [18, "?", 103497, "Some-college", 10, "Never-married", "?", "Own-child", "White", "Female", 0, 0, 30, "United-States"]
    [34, "Private", 198693, "10th", 6, "Never-married", "Other-service", "Not-in-family", "White", "Male", 0, 0, 30, "United-States"]
    [29, "?", 227026, "HS-grad", 9, "Never-married", "?", "Unmarried", "Black", "Male", 0, 0, 40, "United-States"]
    [63, "Self-emp-not-inc", 104626, "Prof-school", 15, "Married-civ-spouse", "Prof-specialty", "Husband", "White", "Male", 3103, 0, 32, "United-States"]
    [24, "Private", 369667, "Some-college", 10, "Never-married", "Other-service", "Unmarried", "White", "Female", 0, 0, 40, "United-States"]
    [55, "Private", 104996, "7th-8th", 4, "Married-civ-spouse", "Craft-repair", "Husband", "White", "Male", 0, 0, 10, "United-States"]

Notez que le format des instances d'entrée doit correspondre au format attendu par le modèle. Dans cet exemple, le modèle Census nécessite 14 caractéristiques. Par conséquent, vos données d'entrée doivent constituer une matrice de forme (num_instances, 14).

API REST

{
  "instances": [

    [25, "Private", 226802, "11th", 7, "Never-married", "Machine-op-inspct", "Own-child", "Black", "Male", 0, 0, 40, "United-States"],
    [38, "Private", 89814, "HS-grad", 9, "Married-civ-spouse", "Farming-fishing", "Husband", "White", "Male", 0, 0, 50, "United-States"],
    [28, "Local-gov", 336951, "Assoc-acdm", 12, "Married-civ-spouse", "Protective-serv", "Husband", "White", "Male", 0, 0, 40, "United-States"],
    [44, "Private", 160323, "Some-college", 10, "Married-civ-spouse", "Machine-op-inspct", "Husband", "Black", "Male", 7688, 0, 40, "United-States"],
    [18, "?", 103497, "Some-college", 10, "Never-married", "?", "Own-child", "White", "Female", 0, 0, 30, "United-States"],
    [34, "Private", 198693, "10th", 6, "Never-married", "Other-service", "Not-in-family", "White", "Male", 0, 0, 30, "United-States"],
    [29, "?", 227026, "HS-grad", 9, "Never-married", "?", "Unmarried", "Black", "Male", 0, 0, 40, "United-States"],
    [63, "Self-emp-not-inc", 104626, "Prof-school", 15, "Married-civ-spouse", "Prof-specialty", "Husband", "White", "Male", 3103, 0, 32, "United-States"],
    [24, "Private", 369667, "Some-college", 10, "Never-married", "Other-service", "Unmarried", "White", "Female", 0, 0, 40, "United-States"],
    [55, "Private", 104996, "7th-8th", 4, "Married-civ-spouse", "Craft-repair", "Husband", "White", "Male", 0, 0, 10, "United-States"]
  ]
}

En savoir plus sur la mise en forme de vos entrées pour la prédiction en ligne.

Tester le modèle avec des prédictions locales

Vous pouvez utiliser la commande gcloud ai-platform local predict pour tester la façon dont votre modèle diffuse des prédictions avant de le déployer dans AI Platform Prediction. La commande effectue des prédictions à l'aide des dépendances de votre environnement local et renvoie les résultats au même format que la commande gcloud ai-platform predict lorsqu'elle effectue des prédictions en ligne. Les tests de prédictions en local peuvent vous permettre de détecter les erreurs avant d'engager des coûts pour les requêtes de prédiction en ligne.

Pour l'argument --model-dir, spécifiez un répertoire contenant votre modèle de machine learning exporté sur votre ordinateur local ou dans Cloud Storage. Pour l'argument --framework, spécifiez tensorflow, scikit-learn ou xgboost. Vous ne pouvez pas exécuter la commande gcloud ai-platform local predict avec une routine de prédiction personnalisée.

L'exemple suivant montre comment effectuer une prédiction locale :

gcloud ai-platform local predict --model-dir LOCAL_OR_CLOUD_STORAGE_PATH_TO_MODEL_DIRECTORY/ \
  --json-instances LOCAL_PATH_TO_PREDICTION_INPUT.JSON \
  --framework NAME_OF_FRAMEWORK

Déployer des modèles et des versions

AI Platform Prediction organise vos modèles entraînés à l'aide de ressources de modèle et de version. Un modèle AI Platform Prediction est un conteneur pour les versions de votre modèle de machine learning.

Pour déployer un modèle, vous créez une ressource de modèle dans AI Platform Prediction, vous créez ensuite une version de ce modèle, puis vous associez la version du modèle au fichier de modèle stocké dans Cloud Storage.

Créer une ressource de modèle

AI Platform Prediction organise les différentes versions de votre modèle à l'aide de ressources de modèle.

À ce stade, vous devez décider si vous souhaitez que les versions de modèle appartenant à ce modèle utilisent un point de terminaison régional ou le point de terminaison global. Dans la plupart des cas, choisissez un point de terminaison régional. Si vous avez besoin d'une fonctionnalité disponible seulement sur les anciens types de machines (MLS1), utilisez le point de terminaison global.

Vous devez également décider à ce stade si vous souhaitez que les versions de modèle appartenant à ce modèle exportent les journaux lorsqu'ils diffusent des prédictions. Les exemples suivants n'activent pas la journalisation. Découvrez comment activer la journalisation.

Console

Accédez à la page des modèles AI Platform Prediction dans la console Google Cloud :

Accéder à la page des modèles
Cliquez sur le bouton Nouveau modèle en haut de la page Modèles. La page Créer un modèle s'affiche.
Saisissez un nom unique pour le modèle dans le champ Nom du modèle.
Lorsque la case Utiliser le point de terminaison régional est cochée, AI Platform Prediction utilise un point de terminaison régional. Pour utiliser le point de terminaison mondial, décochez la case Utiliser le point de terminaison régional.
Dans la liste déroulante Région, sélectionnez un emplacement pour vos nœuds de prédiction. Les régions disponibles diffèrent selon que vous utilisez un point de terminaison régional ou un point de terminaison mondial.
Cliquez sur Créer.
Vérifiez que vous êtes revenu sur la page Modèles et que le nouveau modèle figure dans la liste.

gcloud

Point de terminaison régional

Exécutez la commande suivante :

gcloud ai-platform models create MODEL_NAME \
  --region=REGION

Remplacez l'élément suivant :

MODEL_NAME : nom que vous choisissez pour votre modèle.
REGION : région du point de terminaison régional dans lequel vous souhaitez que les nœuds de prédiction s'exécutent. Il doit s'agir d'une région compatible avec les types de machines Compute Engine (N1).

Si vous ne spécifiez pas l'option --region, gcloud CLI vous invite à sélectionner un point de terminaison régional (ou à utiliser us-central sur le point de terminaison global).

Vous pouvez également définir la propriété ai_platform/region sur une région spécifique afin de vous assurer que gcloud CLI utilise toujours le point de terminaison régional correspondant pour AI Platform Prediction, même lorsque vous ne spécifiez pas l'option --region. (Cette configuration ne s'applique pas aux commandes du groupe de commandes gcloud ai-platform operations.)

Point de terminaison mondial

Exécutez la commande suivante :

gcloud ai-platform models create MODEL_NAME \
  --regions=REGION

Remplacez l'élément suivant :

MODEL_NAME : nom que vous choisissez pour votre modèle.
REGION : région du point de terminaison global où vous souhaitez exécuter les nœuds de prédiction. Il doit s'agir d'une région compatible avec les anciens types de machines (MLS1).

Si vous ne spécifiez pas l'option --regions, gcloud CLI vous invite à sélectionner un point de terminaison régional (ou à utiliser us-central1 sur le point de terminaison global).

API REST

Point de terminaison régional

Mettez en forme votre requête en plaçant l'objet de modèle dans le corps de la requête. Spécifiez au moins le nom de votre modèle en remplaçant MODEL_NAME dans l'exemple suivant :
```
{
  "name": "MODEL_NAME"
}
```
Effectuez un appel d'API REST vers l'URL suivante, en remplaçant PROJECT_ID par l'ID de votre projet Google Cloud :
```
POST https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models/
```
Remplacez l'élément suivant :
- REGION : région du point de terminaison régional dans lequel déployer votre modèle. Il doit s'agir d'une région compatible avec les types de machines Compute Engine (N1).
- PROJECT_ID : ID de votre projet Google Cloud.
Par exemple, vous pouvez envoyer la requête suivante à l'aide de la commande curl. Cette commande autorise la requête à l'aide des identifiants associés à votre installation de Google Cloud CLI.
```
curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "MODEL_NAME"}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models"
```
L'API renvoie une réponse semblable à la suivante :
```
{
  "name": "projects/PROJECT_ID/models/MODEL_NAME",
  "regions": [
    "REGION"
  ]
}
```

Point de terminaison mondial

Mettez en forme votre requête en plaçant l'objet de modèle dans le corps de la requête. Spécifiez au moins le nom de votre modèle en remplaçant MODEL_NAME dans l'exemple suivant, ainsi qu'une région en remplaçant REGION par une région compatible avec les anciens types de machines (MLS1) :
```
{
  "name": "MODEL_NAME",
  "regions": ["REGION"]
}
```

Effectuez un appel d'API REST vers l'URL suivante, en remplaçant PROJECT_ID par l'ID de votre projet Google Cloud :

POST https://ml.googleapis.com/v1/projects/PROJECT_ID/models/

Par exemple, vous pouvez envoyer la requête suivante à l'aide de la commande curl. Cette commande autorise la requête à l'aide des identifiants associés à votre installation de Google Cloud CLI.

curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "MODEL_NAME", "regions": ["REGION"]}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://ml.googleapis.com/v1/projects/PROJECT_ID/models"

L'API renvoie une réponse semblable à la suivante :

{
  "name": "projects/PROJECT_ID/models/MODEL_NAME",
  "regions": [
    "REGION"
  ]
}

Reportez-vous à la page API du modèle AI Platform Prediction pour plus d'informations.

Créer une version de modèle

Vous êtes prêt à créer une version de modèle avec le modèle entraîné que vous avez importé tout à l'heure dans Cloud Storage. Lorsque vous créez une version, vous pouvez spécifier un certain nombre de paramètres. La liste suivante décrit les paramètres courants, dont certains sont obligatoires :

name : doit être unique dans le modèle AI Platform Prediction.
deploymentUri : chemin d'accès au répertoire de modèle dans Cloud Storage.
- Si vous déployez un modèle TensorFlow, il s'agit d'un répertoire SavedModel.
- Si vous déployez un modèle scikit-learn ou XGBoost, il s'agit du répertoire contenant votre fichier model.joblib, model.pkl ou model.bst.
- Si vous déployez une routine de prédiction personnalisée, il s'agit du répertoire contenant tous vos artefacts de modèle. La taille totale de ce répertoire doit être inférieure ou égale à 500 Mo.
framework : TENSORFLOW, SCIKIT_LEARN ou XGBOOST.
runtimeVersion : version d'exécution basée sur les dépendances dont votre modèle a besoin. Si vous déployez un modèle scikit-learn ou XGBoost, celle-ci doit au moins correspondre à la version 1.4. Si vous prévoyez d'utiliser la version de modèle pour la prédiction par lot, vous devez utiliser la version d'exécution 2.1 ou une version antérieure.
pythonVersion : la version de Python doit être définie à la valeur 3.5 (pour les versions d'exécution 1.4 à 1.14) ou 3.7 (pour les versions d'exécution 1.15 et ultérieures) afin d'être compatible avec les fichiers de modèle exportés avec Python 3. Ce paramètre peut également être défini sur 2.7 pour les versions d'exécution 1.15 et antérieures.
machineType (facultatif) : type de machine virtuelle utilisé par AI Platform Prediction pour les nœuds qui diffusent des prédictions. Apprenez-en plus sur les types de machines. Si ce paramètre n'est pas défini, sa valeur par défaut est n1-standard-2 sur les points de terminaison régionaux, et mls1-c1-m2 sur le point de terminaison global.

Si la version de votre modèle utilise un type de machine Compute Engine (N1) et moins de deux nœuds, elle est exclue du contrat de niveau de service d'AI Platform Training et d'AI Platform Prediction.

En d'autres termes, si vous utilisez un type de machine Compute Engine (N1), vous devez définir manualScaling.nodes ou autoScaling.minNodes sur 2 ou plus pour que la version du modèle soit couverte par le contrat de niveau de service.

L'utilisation du scaling automatique avec les GPU est également disponible en version bêta. Ainsi, les versions de modèle utilisant le scaling automatique avec des GPU ne sont pas couvertes par le contrat de niveau de service.

Pour en savoir plus sur chacun de ces paramètres, ainsi que sur d'autres paramètres moins courants, consultez la documentation de référence de l'API pour la ressource de version.

En outre, si vous avez créé votre modèle sur un point de terminaison régional, assurez-vous également de créer la version sur le même point de terminaison régional.

Console

Accédez à la page des modèles AI Platform Prediction dans la console Google Cloud :

Accéder à la page des modèles
Sur la page Modèles, sélectionnez le nom de la ressource de modèle que vous souhaitez utiliser pour créer votre version. La page Informations sur le modèle s'affiche.
En haut de la page Informations sur le modèle, cliquez sur le bouton Nouvelle version. La page Créer une version s'affiche.
Saisissez le nom de la version dans le champ Nom. Saisissez éventuellement une description de cette version dans le champ Description.
Renseignez les informations relatives à l'entraînement de votre modèle à l'aide des listes déroulantes correspondantes :
- Sélectionnez la Version Python utilisée pour entraîner le modèle.
- Sélectionnez le Framework et la Version du framework.
- Sélectionnez la Version d'exécution de ML. En savoir plus sur les versions d'exécution d'AI Platform Prediction.
Si vous le souhaitez, sélectionnez un Type de machine pour exécuter la prédiction en ligne.
Dans le champ URI du modèle, saisissez l'emplacement du bucket Cloud Storage dans lequel vous avez importé le fichier de modèle. Vous pouvez utiliser le bouton Parcourir pour trouver le chemin d'accès.

Veillez à indiquer le chemin d'accès du répertoire contenant le fichier, et non celui du fichier de modèle proprement dit. Par exemple, utilisez gs://your_bucket_name/model-dir/ au lieu de gs://your_bucket_name/model-dir/saved_model.pb ou gs://your_bucket_name/model-dir/model.pkl.
Sélectionnez une option de Scaling pour le déploiement de la prédiction en ligne :
- Si vous sélectionnez "Autoscaling", le champ facultatif Nombre minimal de nœuds s'affiche. Vous pouvez alors saisir le nombre minimal de nœuds à exécuter en permanence en cas de réduction du service.
- Si vous sélectionnez "Scaling manuel", vous devez saisir le Nombre de nœuds qui doivent être exécutés à tout moment.
Découvrez en quoi les options de scaling diffèrent selon le type de machine.

Consultez la section Plus d'informations sur les frais liés aux prédictions.
Pour terminer la création de votre version de modèle, cliquez sur Enregistrer.

gcloud

Définissez les variables d'environnement pour stocker le chemin d'accès au répertoire Cloud Storage dans lequel se trouve le fichier binaire du modèle, le nom du modèle, le nom de la version et le framework de votre choix.

Lorsque vous créez une version avec gcloud CLI, vous pouvez fournir le nom du framework en majuscules avec des traits de soulignement (par exemple, SCIKIT_LEARN) ou en minuscules avec des tirets (par exemple, scikit-learn). Les deux options permettent d'obtenir un comportement identique.

Remplacez [VALUES_IN_BRACKETS] par les valeurs appropriées :
```
MODEL_DIR="gs://your_bucket_name/"
VERSION_NAME="[YOUR-VERSION-NAME]"
MODEL_NAME="[YOUR-MODEL-NAME]"
FRAMEWORK="[YOUR-FRAMEWORK_NAME]"
```
Créez la version :
```
gcloud ai-platform versions create $VERSION_NAME \
  --model=$MODEL_NAME \
  --origin=$MODEL_DIR \
  --runtime-version=2.11 \
  --framework=$FRAMEWORK \
  --python-version=3.7 \
  --region=REGION \
  --machine-type=MACHINE_TYPE
```
Remplacez l'élément suivant :
- REGION : région du point de terminaison régional où vous avez créé le modèle. Si vous avez créé le modèle sur le point de terminaison mondial, omettez l'option --region.
- MACHINE_TYPE : type de machine déterminant les ressources de calcul disponibles pour vos nœuds de prédiction.
La création de la version prend quelques minutes. Une fois la version prête, vous devez obtenir le résultat suivant :
```
Creating version (this might take a few minutes)......done.
```

Obtenez des informations sur la nouvelle version :

gcloud ai-platform versions describe $VERSION_NAME \
  --model=$MODEL_NAME

Le résultat doit ressembler à ce qui suit :

createTime: '2018-02-28T16:30:45Z'
deploymentUri: gs://your_bucket_name
framework: [YOUR-FRAMEWORK-NAME]
machineType: mls1-c1-m2
name: projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]
pythonVersion: '3.7'
runtimeVersion: '2.11'
state: READY

API REST

Mettez en forme le corps de votre requête pour y inclure l'objet de version. Cet exemple spécifie la version name, deploymentUri, runtimeVersion, framework et machineType. Remplacez [VALUES_IN_BRACKETS] par les valeurs appropriées :

{
  "name": "[YOUR-VERSION-NAME]",
  "deploymentUri": "gs://your_bucket_name/",
  "runtimeVersion": "2.11",
  "framework": "[YOUR_FRAMEWORK_NAME]",
  "pythonVersion": "3.7",
  "machineType": "[YOUR_MACHINE_TYPE]"
}

Envoyez un appel de l'API REST au chemin d'accès suivant, en remplaçant les expressions entre crochets ([VALUES_IN_BRACKETS]) par les valeurs appropriées :

POST https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions

Remplacez REGION par la région du point de terminaison régional où vous avez créé votre modèle. Si vous avez créé votre modèle sur le point de terminaison mondial, utilisez ml.googleapis.com.

Par exemple, vous pouvez envoyer la requête suivante à l'aide de la commande curl :

curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "[YOUR-VERSION-NAME]", "deploymentUri": "gs://your_bucket_name/", "runtimeVersion": "2.11", "framework": "[YOUR_FRAMEWORK_NAME]", "pythonVersion": "3.7", "machineType": "[YOUR_MACHINE_TYPE]"}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions"

La création de la version prend quelques minutes. Une fois la version prête, vous devez obtenir un résultat semblable à celui-ci :

{
  "name": "projects/[YOUR-PROJECT-ID]/operations/create_[YOUR-MODEL-NAME]_[YOUR-VERSION-NAME]-[TIMESTAMP]",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.ml.v1.OperationMetadata",
    "createTime": "2018-07-07T02:51:50Z",
    "operationType": "CREATE_VERSION",
    "modelName": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]",
    "version": {
      "name": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]",
      "deploymentUri": "gs://your_bucket_name",
      "createTime": "2018-07-07T02:51:49Z",
      "runtimeVersion": "2.11",
      "framework": "[YOUR_FRAMEWORK_NAME]",
      "machineType": "[YOUR_MACHINE_TYPE]",
      "pythonVersion": "3.7"
    }
  }
}

Envoyer une requête de prédiction en ligne

Une fois que vous avez créé une version de modèle, AI Platform Prediction démarre un nouveau serveur prêt à diffuser les requêtes de prédiction.

Cette section explique :

comment tester le modèle avec gcloud en envoyant des requêtes pour des ensembles de données plus petits ;
comment envoyer des requêtes plus importantes pour l'ensemble de données de test complet à l'aide de la bibliothèque cliente Python, et afficher les dix premiers résultats.

gcloud

Cette section explique comment envoyer une requête de prédiction à l'aide du fichier input.json que vous avez créé lors d'une étape précédente.

Définissez les variables d'environnement pour le nom du modèle, le nom de la version et le nom du fichier d'entrée. Remplacez [VALUES_IN_BRACKETS] par les valeurs appropriées :
```
MODEL_NAME="[YOUR-MODEL-NAME]"
VERSION_NAME="[YOUR-VERSION-NAME]"
INPUT_FILE="input.json"
```
Envoyez la requête de prédiction :
```
gcloud ai-platform predict --model $MODEL_NAME --version \
  $VERSION_NAME --json-instances $INPUT_FILE
```
Les résultats de la prédiction contiennent True si le revenu de la personne est prédit supérieur à 50 000 $ par an, et False dans le cas contraire. Par exemple, les dix premiers résultats peuvent ressembler à ce qui suit :
```
[False, False, False, True, False, False, False, False, False, False]
```

API REST

Cette section explique comment envoyer une requête de prédiction à l'aide du fichier input.json que vous avez créé lors de l'étape précédente.

Envoyez la ou les requêtes de prédiction :

curl -X POST -H "Content-Type: application/json" -d @input.json \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
"https://ml.googleapis.com/v1/projects/${PROJECT_ID}/models/${MODEL_NAME}/versions/${VERSION_NAME}:predict"

Les résultats de la prédiction contiennent True si le revenu de la personne est prédit supérieur à 50 000 $ par an, et False dans le cas contraire. Les résultats de la prédiction s'affichent dans la console sous la forme d'une liste de valeurs booléennes. Par exemple, les dix premiers résultats peuvent ressembler à ce qui suit :

{"predictions": [false, false, false, true, false, false, false, false, false, false]}

Python

Cet exemple utilise la bibliothèque cliente Python afin d'envoyer des requêtes de prédiction pour l'ensemble de données de recensement complet, et affiche les dix premiers résultats. Apprenez-en plus sur l'utilisation de la bibliothèque cliente Python.

Remplacez [VALUES_IN_BRACKETS] par les valeurs appropriées :

import googleapiclient.discovery

# Fill in your PROJECT_ID, VERSION_NAME and MODEL_NAME before running
# this code.

PROJECT_ID = [YOUR PROJECT_ID HERE]
VERSION_NAME = [YOUR VERSION_NAME HERE]
MODEL_NAME = [YOUR MODEL_NAME HERE]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}'.format(PROJECT_ID, MODEL_NAME)
name += '/versions/{}'.format(VERSION_NAME)

# Due to the size of the data, it needs to be split in 2
first_half = test_features[:int(len(test_features)/2)]
second_half = test_features[int(len(test_features)/2):]

complete_results = []
for data in [first_half, second_half]:
    responses = service.projects().predict(
        name=name,
        body={'instances': data}
    ).execute()

    if 'error' in responses:
        print(response['error'])
    else:
        complete_results.extend(responses['predictions'])

# Print the first 10 responses
for i, response in enumerate(complete_results[:10]):
    print('Prediction: {}\tLabel: {}'.format(response, test_labels[i]))

Les résultats de la prédiction contiennent True si le revenu de la personne est prédit supérieur à 50 000 $ par an, et False dans le cas contraire. Par exemple, les dix premiers résultats peuvent ressembler à ce qui suit :

Prediction: False Label: False
Prediction: False Label: False
Prediction: True  Label: True
Prediction: True  Label: True
Prediction: False Label: False
Prediction: False Label: False
Prediction: False Label: False
Prediction: True  Label: True
Prediction: False Label: False
Prediction: False Label: False

Consultez plus d'informations sur chaque paramètre d'entrée dans les détails sur les requêtes de prédiction de l'API d'AI Platform Prediction.

À propos des données

Données de recensement fournies par : Lichman, M. (2013). UCI Machine Learning Repository : http://archive.ics.uci.edu/ml. Irvine, Californie : Université de Californie, School of Information and Computer Science. Cet ensemble de données est accessible au public et peut être utilisé selon les conditions définies par sa source (http://archive.ics.uci.edu/ml). Il est fourni "EN L'ÉTAT", sans aucune garantie expresse ou implicite de la part de Google. Google décline toute responsabilité pour tout dommage direct ou indirect résultant de l'utilisation de cet ensemble de données.

Étapes suivantes

Essayez ce tutoriel sous forme de notebook Jupyter sur GitHub.
Consultez d'autres d'exemples de notebooks scikit-learn sur GitHub.