Entraînement avec scikit-learn sur AI Platform Training

Le service AI Platform Training gère les ressources informatiques dans le cloud pour entraîner vos modèles. Cette page décrit le processus d'entraînement d'un modèle scikit-learn à l'aide de AI Platform Training.

Dans ce tutoriel, vous allez entraîner un modèle simple pour prédire le niveau de revenu d'une personne en fonction d'un ensemble de données sur les revenus collectées par recensement. Vous allez créer une application d'entraînement en local, puis vous l'importerez dans Cloud Storage et soumettrez une tâche d'entraînement. Le service AI Platform Training écrit ses résultats dans votre bucket Cloud Storage et crée des journaux dans Cloud Logging.

Ce contenu est également disponible sur GitHub en tant que notebook Jupyter.

Entraîner un modèle sur AI Platform Training

Vous pouvez entraîner votre modèle sur AI Platform Training en trois étapes :

  • Créer le fichier de modèle Python
    • Ajoutez le code permettant de télécharger vos données depuis Cloud Storage afin qu'AI Platform Training puisse les utiliser.
    • Une fois le modèle entraîné dans AI Platform Training, ajoutez du code pour exporter et enregistrer le modèle dans Cloud Storage.
  • Préparer un package d'application d'entraînement
  • Envoyer la tâche d'entraînement

Avant de commencer

Procédez comme suit pour configurer un compte GCP, activer l'API AI Platform Training, puis installer et activer le SDK Cloud.

Configurer le projet GCP

  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

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). Cloud Shell offre un moyen rapide d'essayer AI Platform Training, mais n'est pas adapté aux tâches de développement continu.

macOS

  1. Vérifiez que Python est installé
    Si ce n'est pas le cas, installez Python.

    python -V

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

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

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

  1. Ouvrez Google Cloud Console.

    Google Cloud Console

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

    Activer Google Cloud Shell

    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.

    Session Cloud Shell

    Votre session Cloud Shell est prête à l'emploi.

  3. 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 Training:

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

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 :

Configurer un bucket Cloud Storage

Vous aurez besoin d'un bucket Cloud Storage pour stocker votre code d'entraînement ainsi que les dépendances. Pour les besoins de ce tutoriel, il est plus facile d'utiliser un bucket Cloud Storage dédié dans le même projet que celui utilisé pour AI Platform Training.

Si vous utilisez un bucket dans un autre projet, vous devez vous assurer que votre compte de service AI Platform Training peut accéder à votre code d'entraînement et à vos dépendances dans Cloud Storage. Sans les autorisations appropriées, votre tâche d'entraînement ne peut pas aboutir. Découvrez comment accorder des autorisations pour le stockage.

Veillez à utiliser ou à configurer un bucket situé dans la même région que celle permettant d'exécuter les tâches d'entraînement. Consultez les régions disponibles pour les services AI Platform Training.

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 Training, vous devez explicitement accorder l'accès aux comptes de service AI Platform Training.

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

  2. Vérifiez le nom du bucket que vous avez créé.

    echo $BUCKET_NAME

  3. 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 Training. Consultez les régions disponibles pour les services AI Platform Training.

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

    REGION=us-central1

  4. Créez le bucket :

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

À propos des données

L'ensemble de données sur le revenu collectées par recensement que cet exemple utilise pour l'entraînement est hébergé par l'UCI Machine Learning Repository (dépôt de machine learning de l'Université de Californie à Irvine).

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.

Pour plus de facilité, nous avons hébergé les données dans un bucket Cloud Storage public (gs://cloud-samples-data/ai-platform/sklearn/census_data/), que vous pouvez télécharger dans votre fichier d'entraînement Python.

Créer le fichier de modèle Python

Vous trouverez l'intégralité du code d'entraînement utilisé dans cette section sur GitHub : train.py.

Le reste de cette section contient des explications sur ce que fait le code d'entraînement.

Prérequis

Importez les bibliothèques suivantes à partir de Python, Google Cloud CLI et scikit-learn. Définissez une variable pour le nom de votre bucket Cloud Storage.

import datetime
import pandas as pd
import joblib

from google.cloud import storage

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


# TODO: REPLACE 'YOUR_BUCKET_NAME' with your GCS Bucket name.
BUCKET_NAME = 'YOUR_BUCKET_NAME'

Importer des données depuis Cloud Storage

Au cours du processus de développement standard, vous importez vos propres données dans Cloud Storage de sorte qu'AI Platform Training puisse y accéder. Les données de ce tutoriel sont hébergées dans un bucket public : gs://cloud-samples-data/ai-platform/sklearn/census_data/.

Le code ci-dessous permet de télécharger l'ensemble de données d'entraînement adult.data. (Les données d'évaluation sont disponibles dans adult.test, mais ne sont pas utilisées dans ce tutoriel.)

# Public bucket holding the census data
bucket = storage.Client().bucket('cloud-samples-data')

# Path to the data inside the public bucket
blob = bucket.blob('ai-platform/sklearn/census_data/adult.data')
# Download the data
blob.download_to_filename('adult.data')

Ajouter le code du modèle

Le code d'entraînement du modèle effectue quelques étapes de base :

  • Définir et charger les données
  • Convertir les caractéristiques catégorielles en caractéristiques numériques
  • Extraire les caractéristiques numériques via un pipeline scikit-learn
  • Exporter et enregistrer le modèle dans Cloud Storage

Définir et charger les données

# 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('./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).values.tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = (raw_training_data['income-level'] == ' >50K').values.tolist()

Convertir les caractéristiques catégoriques en caractéristiques numériques

# 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: [['State-gov']]
        # Build the scores array.
        scores = [0] * len(COLUMNS[:-1])
        # This column is the categorical column we want to extract.
        scores[i] = 1
        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)])))

Extraire les caractéristiques numériques via un pipeline scikit-learn

# 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 et enregistrer le modèle dans Cloud Storage

Si votre bucket Cloud Storage se trouve dans le même projet que celui utilisé pour AI Platform Training, alors AI Platform Training peut lire et écrire dans votre bucket. Dans le cas contraire, vous devez vous assurer que le projet que vous utilisez pour exécuter AI Platform Training peut accéder à votre bucket Cloud Storage. Découvrez comment accorder des autorisations pour le stockage.

Assurez-vous de nommer votre fichier modèle model.pkl ou model.joblib si vous souhaitez l'utiliser pour demander des prédictions en ligne avec AI Platform Prediction.

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

# Upload the model to GCS
bucket = storage.Client().bucket(BUCKET_NAME)
blob = bucket.blob('{}/{}'.format(
    datetime.datetime.now().strftime('census_%Y%m%d_%H%M%S'),
    model))
blob.upload_from_filename(model)

Vérifier l'importation du fichier de modèle dans Cloud Storage (facultatif)

Dans la ligne de commande, affichez le contenu du dossier du modèle de destination pour vérifier que votre fichier de modèle a bien été importé dans Cloud Storage. Si ce n'est pas déjà fait, définissez une variable d'environnement (BUCKET_NAME) pour le nom de votre bucket.

gcloud storage ls gs://$BUCKET_NAME/census_*

Le résultat doit se présenter comme suit :

gs://[YOUR-PROJECT-ID]/census_[DATE]_[TIME]/model.joblib

Créer un package d'application d'entraînement

La méthode la plus simple (et recommandée) pour créer un package d'application d'entraînement consiste à se servir de gcloud pour empaqueter et importer l'application lorsque vous envoyez la tâche d'entraînement. Cette méthode permet de créer une structure de fichiers très simple ne comportant que deux fichiers. Pour ce tutoriel, la structure de fichiers de votre package d'application d'entraînement doit se présenter comme suit :

census_training/
    __init__.py
    train.py

  1. Créez un répertoire en local :

    mkdir census_training

  2. Créez un fichier vierge nommé __init__.py :

    touch census_training/__init__.py

  3. Enregistrez le code d'entraînement dans un seul fichier Python, puis enregistrez ce fichier dans votre répertoire census_training. Consultez l'exemple de code pour train.py. Vous pouvez utiliser cURL pour télécharger et enregistrer le fichier :

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/sklearn/notebooks/census_training/train.py > census_training/train.py

Découvrez comment empaqueter une application d'entraînement.

Envoyer une tâche d'entraînement

Dans cette section, vous allez utiliser la commande gcloud ai-platform jobs submit training pour envoyer votre tâche d'entraînement.

Spécifier les paramètres de la tâche d'entraînement

Définissez les variables d'environnement suivantes pour chaque paramètre spécifié dans votre requête de tâche d'entraînement :

  • PROJECT_ID : utilisez l'ID du projet (PROJECT_ID) correspondant à votre projet Google Cloud.
  • BUCKET_NAME : indiquez le nom du bucket Cloud Storage.
  • JOB_NAME : spécifiez le nom à utiliser pour la tâche (composé uniquement de lettres majuscules/minuscules, de chiffres et de traits de soulignement, et commençant par une lettre). Dans le cas présent : census_training_$(date +"%Y%m%d_%H%M%S").
  • JOB_DIR : indiquez le chemin d'accès de l'emplacement Cloud Storage à utiliser pour les fichiers de sortie de votre tâche d'entraînement. Par exemple, gs://$BUCKET_NAME/scikit_learn_job_dir.
  • TRAINING_PACKAGE_PATH : spécifiez le chemin d'accès local du répertoire racine de votre application d'entraînement. Dans le cas présent : ./census_training/.
  • MAIN_TRAINER_MODULE : spécifiez le fichier que doit exécuter le service d'entraînement d'AI Platform Training. Ce fichier est au format [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. Dans le cas présent : census_training.train.
  • REGION : spécifiez le nom de la région utilisée pour l'exécution de la tâche d'entraînement. Utilisez l'une des régions disponibles pour le service d'entraînement d'AI Platform Training. Assurez-vous que votre bucket Cloud Storage se trouve dans la même région.
  • RUNTIME_VERSION : spécifiez une version d'exécution d'AI Platform Training compatible avec scikit-learn. Dans cet exemple, 2.11.
  • PYTHON_VERSION : indiquez la version de Python à utiliser pour la tâche. Pour ce tutoriel, spécifiez Python 3.7.
  • SCALE_TIER : indiquez une spécification de cluster prédéfinie pour les machines appelées à exécuter votre tâche d'entraînement. Dans le cas présent : BASIC. Vous pouvez également utiliser les niveaux d'évolutivité personnalisés afin de définir votre propre configuration de cluster pour l'entraînement.

Pour plus de commodité, les variables d'environnement de ce tutoriel sont répertoriées ci-dessous. Remplacez [VALUES-IN-BRACKETS] par les valeurs appropriées :

PROJECT_ID=[YOUR-PROJECT-ID]
BUCKET_NAME=[YOUR-BUCKET-NAME]
JOB_NAME=census_training_$(date +"%Y%m%d_%H%M%S")
JOB_DIR=gs://$BUCKET_NAME/scikit_learn_job_dir
TRAINING_PACKAGE_PATH="[YOUR-LOCAL-PATH-TO-TRAINING-PACKAGE]/census_training/"
MAIN_TRAINER_MODULE=census_training.train
REGION=us-central1
RUNTIME_VERSION=2.11
PYTHON_VERSION=3.7
SCALE_TIER=BASIC

Envoyez la requête :

gcloud ai-platform jobs submit training $JOB_NAME \
  --job-dir $JOB_DIR \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE \
  --region $REGION \
  --runtime-version=$RUNTIME_VERSION \
  --python-version=$PYTHON_VERSION \
  --scale-tier $SCALE_TIER

Un résultat semblable aux lignes suivantes doit s'afficher :

Job [census_training_[DATE]_[TIME]] submitted successfully.
Your job is still active. You may view the status of your job with the command

  $ gcloud ai-platform jobs describe census_training_[DATE]_[TIME]

or continue streaming the logs with the command

  $ gcloud ai-platform jobs stream-logs census_training_[DATE]_[TIME]
jobId: census_training_[DATE]_[TIME]
state: QUEUED

Afficher les journaux d'entraînement (facultatif)

AI Platform Training capture tous les flux stdout et stderr, ainsi que toutes les instructions de journalisation. Ces journaux sont stockés dans Logging, et sont visibles pendant et après l'exécution.

Pour afficher les journaux relatifs à votre tâche d'entraînement, procédez comme suit :

Console

  1. Ouvrez la page Tâches d'AI Platform Training.

    Accéder aux tâches dans la console Google Cloud

  2. Sélectionnez le nom du job d'entraînement à inspecter. Vous accédez à la page Informations sur la tâche correspondant à la tâche d'entraînement que vous avez sélectionnée.

  3. Dans les détails de la tâche, sélectionnez le lien Afficher les journaux. Vous accédez à la page "Journaux" permettant de rechercher et de filtrer les journaux associés à la tâche d'entraînement que vous avez sélectionnée.

gcloud

Vous pouvez afficher les journaux dans votre terminal à l'aide de la commande gcloud ai-platform jobs stream-logs.

gcloud ai-platform jobs stream-logs $JOB_NAME

Étape suivante