Premiers pas avec l'algorithme intégré large et profond

Grâce aux algorithmes AI Platform Training intégrés, vous pouvez envoyer vos données d'entraînement, sélectionner un algorithme, puis laisser AI Platform Training effectuer les tâches de prétraitement et d'entraînement, sans avoir à écrire le code d'une application d'entraînement.

Présentation

Dans ce tutoriel, vous allez entraîner un modèle large et profond sans écrire de code. Vous enverrez l'ensemble de données sur les revenus collectées par recensement à AI Platform Training pour le prétraitement et l'entraînement, puis vous procéderez au déploiement du modèle sur AI Platform Training afin d'obtenir des prédictions. Le modèle généré prédit la probabilité que le revenu annuel d'un individu dépasse 50 000 $.

Avant de commencer

Pour suivre ce tutoriel sur la ligne de commande, utilisez Cloud Shell ou tout autre environnement dans lequel le SDK Cloud est installé.

Pour configurer un compte GCP, activer les API requises, puis installer et activer le SDK Cloud, procédez comme suit :

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API AI Platform Training & Prediction and Compute Engine.

    Activer les API

  5. Installez et initialisez le SDK Cloud.
  6. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  7. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  8. Activer les API AI Platform Training & Prediction and Compute Engine.

    Activer les API

  9. Installez et initialisez le SDK Cloud.

Prérequis

Pour utiliser des algorithmes intégrés tabulaires, vous devez supprimer la ligne d'en-tête de votre fichier CSV et transférer les valeurs cibles dans la première colonne. Nous avons modifié l'ensemble de données de recensement d'origine pour l'utiliser dans le cadre de ce tutoriel et l'avons hébergé dans un bucket public de Cloud Storage, gs://cloud-samples-data/ai-platform/census/algorithms/data/.

Console

Avant de démarrer votre tâche d'entraînement, vous devez copier les données de notre bucket public Cloud Storage sur votre bucket Cloud Storage.

Copier les échantillons de données dans votre bucket Cloud Storage

  1. Commencez par télécharger les données d'entraînement et de test depuis notre bucket public Cloud Storage.

    1. Accédez à notre bucket public Cloud Storage :

      Obtenir les échantillons de données

    2. Téléchargez à la fois test.csv et train.csv :

      1. Cliquez sur le nom du fichier.

      2. Sur la page Détails des objets, cliquez sur Télécharger. Ces fichiers sont téléchargés dans votre environnement local sous les noms ai-platform_census_algorithms_data_test.csv et ai-platform_census_algorithms_data_train.csv.

  2. Ensuite, importez les données d'entraînement et de test dans votre bucket Cloud Storage.

    1. Accédez à la page "Navigateur" de votre bucket Cloud Storage. Sélectionnez votre projet dans la liste déroulante Sélectionner un projet ou ouvrez-le dans un nouvel onglet :

      Page "Navigateur" de Cloud Storage

    2. Cliquez sur le nom du bucket que vous souhaitez utiliser ou créez-en un si vous n'en avez pas. (Si vous créez un bucket, assurez-vous qu'il s'agit d'un bucket régional et sélectionnez la même région que celle où vous exécutez la tâche d'entraînement AI Platform Training.)

    3. (Facultatif) Cliquez sur Créer un dossier afin de créer un dossier pour les fichiers que vous importez. Saisissez un nom pour le dossier (par exemple, "données"), puis cliquez sur Créer. Ensuite, accédez au nouveau dossier en cliquant sur son nom.

    4. Cliquez sur Importer des fichiers pour importer les fichiers d'entraînement et de test ai-platform_census_algorithms_data_train.csv et ai-platform_census_algorithms_data_test.csv dans votre bucket.

Maintenant que les données sont copiées dans votre bucket, vous pouvez démarrer une tâche d'entraînement en sélectionnant le type d'algorithme que vous souhaitez utiliser.

Sélectionner un algorithme

  1. Accédez à la page "Tâches" d'AI Platform Training dans Google Cloud Console :

    Page "Tâches" d'AI Platform Training

  2. Cliquez sur le bouton Nouvelle tâche d'entraînement. Dans les options qui s'affichent en dessous, cliquez sur Entraînement de l'algorithme intégré. La page Créer une tâche d'entraînement s'affiche.

  3. La création d'une tâche d'entraînement comporte quatre étapes. La première étape concerne l'algorithme d'entraînement. Sélectionnez Algorithme large et profond, puis cliquez sur Suivant.

gcloud

Configurez les variables d'environnement pour votre ID de projet, votre bucket Cloud Storage, le chemin d'accès Cloud Storage aux données d'entraînement et votre option d'algorithme.

Les algorithmes intégrés à AI Platform Training se trouvent dans des conteneurs Docker hébergés dans Container Registry.

PROJECT_ID=YOUR_PROJECT_ID
BUCKET_NAME=YOUR_BUCKET_NAME
REGION="us-central1"
gcloud config set project $PROJECT_ID
gcloud config set compute/region $REGION

# Copy the training data into your Cloud Storage bucket, and set the path
# to your copy of the training data.
TRAINING_DATA_SOURCE=gs://cloud-samples-data/ai-platform/census/algorithms/data/train.csv
TRAINING_DATA_PATH=gs://$BUCKET_NAME/algorithms-demo/data/train.csv
gsutil cp $TRAINING_DATA_SOURCE $TRAINING_DATA_PATH

# Specify the Docker container URI specific to the algorithm.
IMAGE_URI="gcr.io/cloud-ml-algos/wide_deep_learner_cpu:latest"

Envoyer une tâche d'entraînement

Pour envoyer une tâche, vous devez spécifier certains arguments de base associés à l'entraînement, ainsi qu'à l'algorithme large et profond.

Arguments généraux liés à la tâche d'entraînement :

Arguments de la tâche d'entraînement
Argument Description
job-id Identifiant unique de la tâche d'entraînement. Il vous permet de rechercher les journaux d'état de la tâche d'entraînement une fois celle-ci envoyée.
job-dir Chemin d'accès à Cloud Storage, où AI Platform Training enregistre les fichiers d'entraînement après avoir effectué une tâche d'entraînement avec succès.
scale-tier Spécifie les types de machines pour l'entraînement. Utilisez le type BASIC pour sélectionner une configuration sur une seule machine.
master-image-uri URI Container Registry permettant de spécifier le conteneur Docker à utiliser pour la tâche d'entraînement. Utilisez le conteneur défini précédemment pour l'algorithme intégré large et profond en tant que IMAGE_URI.
region Spécifiez la région disponible dans laquelle la tâche d'entraînement doit être exécutée. Pour ce tutoriel, vous pouvez utiliser la région us-central1.

Arguments spécifiques à l'algorithme intégré large et profond :

Arguments algorithmiques
Argument Description
preprocess Argument booléen indiquant si AI Platform Training doit ou non prétraiter les données.
model_type Indique le type de modèle à entraîner : classification ou régression.
training_data_path Emplacement Cloud Storage des données d'entraînement, qui doivent être un fichier CSV.
learning_rate Taux d'apprentissage utilisé par l'optimiseur linéaire.
max_steps Nombre d'étapes nécessaires pour exécuter l'entraînement.
batch_size Nombre d'exemples à utiliser par étape d'entraînement.
dnn_learning_rate Taux d'apprentissage à utiliser par la partie DNN du modèle.
dnn_dropout Probabilité d'abandon.
hidden_units Chaîne séparée par des virgules qui représente le nombre d'unités cachées dans chaque couche.
use_wide Si cette option est définie, les colonnes catégorielles seront utilisées dans la partie large du modèle DNN.
embed_categories Si cette option est définie, les colonnes catégorielles seront incorporées et utilisées dans la partie profonde du modèle.

Pour obtenir une liste détaillée de tous les autres indicateurs d'algorithme large et profond, reportez-vous à la documentation de référence sur l'algorithme intégré large et profond.

Console

  1. Laissez la case Activer le prétraitement automatique des données cochée.

  2. Pour Chemin d'accès aux données d'entraînement, cliquez sur Parcourir. Dans le volet de droite, cliquez sur le nom du bucket dans lequel vous avez importé les données d'entraînement, puis accédez au fichier ai-platform_census_algorithms_data_train.csv.

  3. Conservez les paramètres par défaut dans les champs Données de validation et Données de test.

  4. Dans Répertoire de sortie, saisissez le chemin d'accès à votre bucket Cloud Storage, dans lequel vous souhaitez qu'AI Platform Training stocke les résultats de votre tâche d'entraînement. Vous pouvez renseigner directement le chemin de votre bucket Cloud Storage ou cliquer sur le bouton Parcourir pour le sélectionner.

    Pour maintenir une bonne organisation, créez un répertoire dans votre bucket Cloud Storage destiné à cette tâche d'entraînement. Utilisez pour cela le volet Parcourir.

    Cliquez sur Suivant.

  5. Pour Type de modèle, sélectionnez Classification.

  6. Conservez les paramètres par défaut pour tous les autres champs, puis cliquez sur Suivant.

  7. Sur la page Paramètres de la tâche :

    1. Entrez un ID de tâche unique (tel que "exemple_large_profond").
    2. Entrez une région disponible (telle que "us-central1").
    3. Sélectionnez BASIC pour le niveau d'évolutivité.

    Cliquez sur Terminé pour envoyer la tâche d'entraînement.

gcloud

  1. Configurez tous les arguments de la tâche d'entraînement et de l'algorithme, avant d'utiliser gcloud pour envoyer la tâche :

    DATASET_NAME="census"
    ALGORITHM="wide_deep"
    MODEL_TYPE="classification"
    MODEL_NAME="${DATASET_NAME}_${ALGORITHM}_${MODEL_TYPE}"
    
    # Give a unique name to your training job.
    DATE="$(date '+%Y%m%d_%H%M%S')"
    JOB_ID="${MODEL_NAME}_${DATE}"
    
    # Make sure you have access to this Cloud Storage bucket.
    JOB_DIR="gs://${BUCKET_NAME}/algorithms_training/${MODEL_NAME}/${DATE}"
    
  2. Envoyez la tâche :

    gcloud ai-platform jobs submit training $JOB_ID \
      --master-image-uri=$IMAGE_URI --scale-tier=BASIC --job-dir=$JOB_DIR \
      -- \
      --preprocess --model_type=$MODEL_TYPE --batch_size=250 --learning_rate=0.1 \
      --dnn_learning_rate=0.005 --dnn_dropout=0.1 --hidden_units=10,10,10 \
      --use_wide --embed_categories \
      --max_steps=1000 --training_data_path=$TRAINING_DATA_PATH
    

  3. Une fois la tâche envoyée, vous pouvez afficher les journaux à l'aide des commandes gcloud suivantes :

    gcloud ai-platform jobs describe $JOB_ID
    gcloud ai-platform jobs stream-logs $JOB_ID
    

Comprendre votre répertoire de tâche

Après avoir terminé une tâche d'entraînement, AI Platform Training crée un modèle entraîné dans votre bucket Cloud Storage, accompagné d'autres artefacts. La structure de répertoire suivante apparaît dans votre répertoire JOB_DIR :

  • artifacts/
    • metadata.json
  • model/ (un répertoire TensorFlow SavedModel qui contient également un fichier deployment_config.yaml)
    • saved_model.pb.
    • deployment_config.yaml
  • processed_data/
    • test.csv
    • training.csv
    • validation.csv

Un répertoire de tâche "experiment" contient également divers fichiers de points de contrôle du modèle.

Vérifiez que la structure de répertoire de JOB_DIR correspond à :

gsutil ls -a $JOB_DIR/*

Déployer le modèle entraîné

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 devez créer une ressource de modèle dans AI Platform Prediction, créer une version de ce modèle, puis utiliser le modèle et la version pour demander des prédictions en ligne.

Découvrez comment déployer des modèles sur AI Platform Prediction.

Console

  1. La page Tâches présente une liste de toutes vos tâches d'entraînement. Cliquez sur le nom de la tâche d'entraînement que vous venez d'envoyer ("exemple_large_profond" ou le nom de tâche que vous avez utilisé).

  2. Sur la page Détails de la tâche, vous pouvez afficher la progression générale de la tâche ou cliquer sur Afficher les journaux pour accéder à une vue plus détaillée de la progression.

  3. Lorsque la tâche est réussie, le bouton Déployer un modèle apparaît en haut. Cliquez sur Déployer un modèle.

  4. Sélectionnez "Déployer en tant que nouveau modèle", puis saisissez un nom de modèle, tel que "modèle_large_profond". Ensuite, cliquez sur Confirmer.

  5. Sur la page Créer une version, entrez un nom de version, tel que "v1" et conservez les paramètres par défaut pour tous les autres champs. Cliquez sur Enregistrer.

  6. Sur la page Informations sur le modèle, le nom de votre version s'affiche. La création de la version prend quelques minutes. Lorsque la version est prête, une coche apparaît à côté de son nom.

  7. Cliquez sur le nom de la version ("v1") pour accéder à la page Détails de la version. À l'étape suivante de ce tutoriel, vous allez envoyer une requête de prédiction.

gcloud

Le processus d'entraînement avec l'algorithme large et profond intégré génère un fichier, deployment_config.yaml, qui facilite le déploiement de votre modèle sur AI Platform Prediction pour les prédictions.

  1. Copiez le fichier dans votre répertoire local et affichez son contenu :

    gsutil cp $JOB_DIR/model/deployment_config.yaml .
    cat deployment_config.yaml
    

    Votre fichier deployment_config.yaml doit ressembler à ce qui suit :

    deploymentUri: gs://YOUR_BUCKET_NAME/algorithms_training/census_wide_deep_classification/20190227060114/model
    framework: TENSORFLOW
    labels:
      global_step: '1000'
      job_id: census_wide_deep_classification_20190227060114
      accuracy: '86'
    runtimeVersion: '1.14'
    pythonVersion: '2.7'
    
  2. Créez le modèle et la version dans AI Platform Training :

    MODEL_NAME="${DATASET_NAME}_${ALGORITHM}_${MODEL_TYPE}"
    gcloud ai-platform models create $MODEL_NAME --regions $REGION
    
    # Create a model and a version using the file above.
    VERSION_NAME="v_${DATE}"
    
    gcloud ai-platform versions create $VERSION_NAME \
      --model $MODEL_NAME \
      --config deployment_config.yaml
    

    La création de la version prend quelques minutes.

Obtenir des prédictions en ligne

Lorsque vous demandez des prédictions, vous devez vous assurer que vos données d'entrée sont formatées de la même manière que les données d'entraînement. Avant l'entraînement, AI Platform Training prétraite vos données en les transformant en corpus, présenté dans metadata.json.

Le modèle d'algorithme large et profond applique un prétraitement semblable à vos données d’entrée avant de réaliser les prédictions.

Console

  1. Sur la page Détails de la version correspondant à la version "v1" que vous venez de créer, vous pouvez envoyer un exemple de requête de prédiction.

    Sélectionnez l'onglet Test et utilisation.

  2. Copiez l'exemple suivant dans le champ de saisie :

     {
       "instances": [
         {"csv_row": "44, Private, 160323, Some-college, 10, Married-civ-spouse, Machine-op-inspct, Husband, Black, Male, 7688, 0, 40, United-States", "key": "dummy-key"}
       ]
     }
    
  3. Cliquez sur Test.

    L'exemple de résultat de prédiction comporte plusieurs champs. La liste classes affiche la classe prédite >50K' :

    {
       "predictions": [
         {
           ...
           "classes": [
             ">50K"
           ],
           ...
         }
       ]
     }
    

    Dans ce cas, le modèle déployé prédit que le revenu annuel de l'individu concerné est supérieur à 50 000 $. (Comme l'entraînement n'est pas déterministe, votre modèle peut être différent.)

gcloud

  1. Passez en revue les dernières lignes de metadata.json :

    gsutil cat $JOB_DIR/artifacts/metadata.json | tail
    

    L'objet target_column.mapping montre comment les classes prédites s'afficheront dans les résultats de la prédiction :

        "target_algorithm": "TensorFlow",
        "target_column": {
          "mapping": {
            "0": "<=50K",
            "1": ">50K"
          },
        "num_category": 2,
        "type": "classification"
      }
    }
    
  2. Préparez l'entrée de prédiction pour une instance de données. Notez que vous devez fournir chaque instance de données en tant qu'objet JSON avec les champs suivants :

    • csv_row, qui est une chaîne contenant une ligne de caractéristiques séparées par des virgules au même format que les instances utilisées lors de l'entraînement.
    • key, qui est un identifiant de chaîne unique pour chaque instance. Il agit comme une clé d'instance qui apparaît dans le résultat de la prédiction. Vous pouvez donc faire correspondre chaque prédiction à l'instance d'entrée correspondante.

      Ce champ est nécessaire pour la prédiction par lot, car elle les données et enregistre les résultats dans un ordre imprévisible.

      Pour la prédiction en ligne, qui génère des résultats dans le même ordre que les données saisies, les clés d'instance sont moins importantes. Cet exemple n'effectue de prédiction que sur une seule instance. La valeur de la clé d'instance n'a donc aucune importance.

    Pour envoyer une requête de prédiction en ligne à l'aide de l'outil de ligne de commande gcloud, comme dans cet exemple, écrivez chaque instance sur une ligne dans un fichier JSON délimité par un retour à la ligne.

    Exécutez les commandes suivantes dans votre terminal pour créer une entrée pour une instance unique que vous pouvez envoyer à AI Platform Prediction :

     # A sample record from census dataset. Ground truth is >50K
    RAW_DATA_POINT='44, Private, 160323, Some-college, 10, Married-civ-spouse, Machine-op-inspct, Husband, Black, Male, 7688, 0, 40, United-States'
    
     # Create a prediction request file
    echo "{\"csv_row\": \"$RAW_DATA_POINT\", \"key\": \"dummy-key\"}" > sample_input.json
    
    # Check the prediction request file.
    cat sample_input.json
    
  3. Envoyez la requête de prédiction :

    gcloud ai-platform predict \
      --model $MODEL_NAME \
      --version $VERSION_NAME \
      --json-instances sample_input.json \
      --format "value(predictions[0].classes[0])"
    

    Ce résultat de prédiction est filtré pour n'afficher que la classe prédite :

    >50K
    

Le résultat de la prédiction sera très probablement >50K. Le modèle déployé prédit que le revenu annuel de l'individu concerné est supérieur à 50 000 $. (Comme l'entraînement n'est pas déterministe, votre modèle peut être différent.)

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

Étape suivante