Premiers pas

Avant d'utiliser AI Platform dans le cadre de ce tutoriel, vous devez vous familiariser avec le machine learning et avec TensorFlow. Pour en savoir plus, reportez-vous au Cours d'initiation au Machine Learning avec les API TensorFlow. Vous trouverez également de nombreuses ressources pédagogiques concernant le machine learning sur le site Web Learn with Google AI.

Présentation

Ce document présente l'intégralité du processus d'apprentissage et de prédiction sur AI Platform. Vous allez découvrir un exemple de modèle qui utilise un ensemble de données de recensement pour réaliser les tâches suivantes :

  • Créer une application d'apprentissage TensorFlow et la valider en local
  • Exécuter votre tâche d'apprentissage sur une instance cloud composée d'un nœud de calcul unique
  • Exécuter votre tâche d'apprentissage en tant que tâche d'apprentissage distribuée dans le cloud
  • Optimiser vos hyperparamètres en utilisant les réglages d'hyperparamètres
  • Déployer un modèle pour appuyer la prédiction
  • Demander une prédiction en ligne et afficher la réponse
  • Demander une prédiction par lots

Ce que vous allez créer…

L'exemple présenté ici crée un modèle large et profond pour prédire la catégorie de revenu. Pour cela, le modèle exploite un ensemble de données sur le revenu obtenues par recensement aux États-Unis. Les deux catégories de revenus, également appelées libellés, sont les suivantes :

  • > 50 K : revenus supérieurs à 50 000 dollars
  • <= 50 K : revenus inférieurs ou égaux à 50 000 dollars

Ces modèles utilisent des réseaux neuronaux profonds (DNN) pour apprendre des abstractions générales sur des caractéristiques complexes ou des interactions entre ces caractéristiques. Ils associent ensuite les sorties du DNN à une régression linéaire effectuée sur des fonctions plus simples. Cela se traduit par un équilibre entre la puissance et la vitesse, efficace sur de nombreux problèmes de données structurées.

Pour en savoir plus sur les modèles larges et profonds, vous pouvez consulter l'article du blog Google Research intitulé Wide & Deep Learning: Better Together with TensorFlow (apprentissage large et profond : une collaboration efficace avec TensorFlow).

L'exemple définit le modèle en utilisant la classe préconfigurée DNNCombinedLinearClassifier de TensorFlow. Il définit également les transformations de données qui concernent particulièrement l'ensemble de données de recensement, avant d'attribuer ces caractéristiques (potentiellement) transformées au DNN ou à la partie linéaire du modèle.

Coûts

Cette procédure utilise des composants facturables de Google Cloud Platform, tels que :

  • AI Platform pour les éléments suivants :
    • Formation
    • Prédiction
  • Cloud Storage pour les éléments suivants :
    • Stockage des données d'entrée pour l'apprentissage
    • Préproduction du package d'application d'apprentissage
    • Écriture d'artefacts d'apprentissage
    • Stockage des fichiers de données d'entrée pour la prédiction par lots

Utilisez le simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

Configurer et tester votre environnement Cloud

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

Configurer votre projet GCP

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  4. Activez AI Platform and Compute Engine APIs.

    Activez APIs

  5. Installez et initialisez le SDK Cloud.

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.

Nous recommandons aux utilisateurs de macOS de configurer leur environnement à l'aide des instructions indiquées dans 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 rapidement. Toutefois, son utilisation n'est pas adaptée aux tâches de développement continu.

macOS

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

    python -V
  2. Vérifiez l'installation de pip.
    pip est le gestionnaire de packages de Python, inclus dans les versions actuelles de Python. Vérifiez si pip est déjà installé en exécutant pip --version. Sinon, 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 virtualenv --version. Sinon, 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é cmle-env :

    virtualenv cmle-env
    source cmle-env/bin/activate
  4. Pour les besoins de ce tutoriel, exécutez toutes les autres commandes dans votre environnement virtuel.

    Pour en savoir plus sur l'utilisation de virtualenv, consultez ce guide. Pour quitter virtualenv , exécutez deactivate.

Cloud Shell

  1. Ouvrez la console Google Cloud Platform.

    Console Google Cloud Platform

  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]

    [selected-project-id] correspond à votre ID de projet (saisissez-le sans les crochets).

Vérifier l'installation des composants du SDK Google Cloud

Pour vérifier que les composants du SDK Google Cloud sont bien installés, procédez comme suit :

  1. Répertoriez vos modèles :

    gcloud ml-engine models list
  2. Si vous n'avez pas encore créé de modèle, cette commande renvoie une liste vide :

    Listed 0 items.

    Une fois que vous avez commencé à créer des modèles, vous pouvez les afficher à l'aide de cette même commande.

  3. Si une version de gcloud a déjà été installée, mettez à jour gcloud :

    gcloud components update

Installer TensorFlow :

Pour installer TensorFlow, exécutez la commande suivante :

pip install --user --upgrade tensorflow

Vérifiez l'installation :

python -c "import tensorflow as tf; print('TensorFlow version {} is installed.'.format(tf.VERSION))"

Vous pouvez ignorer les éventuels avertissements indiquant que la bibliothèque TensorFlow n'a pas été compilée de manière à pouvoir utiliser certaines instructions.

Pour plus d'informations sur l'installation de TensorFlow, et en particulier sur les autres options d'installation et sur le dépannage, consultez la documentation de TensorFlow.

Compatibilité de la version Python

AI Platform exécute la version 2.7 de Python par défaut. L'exemple de ce tutoriel utilise également cette version.

Python 3.5 est disponible pour l'entraînement si vous utilisez la version 1.4 de l'environnement d'exécution AI Platform ou une version ultérieure. La prédiction en ligne et par lots fonctionne avec des modèles éduqués, qu'ils aient été entraînés avec les versions 2 ou 3 de Python.

Affichez les consignes pour envoyer une tâche d'apprentissage en utilisant Python 3.5.

Télécharger le code pour ce tutoriel

  1. Téléchargez l'exemple à partir du dépôt GitHub.

macOS

  1. Téléchargez et extrayez le fichier ZIP contenant l'exemple AI Platform.

    Télécharger le fichier ZIP

  2. Ouvrez une fenêtre de terminal et accédez au répertoire contenant le répertoire cloudml-samples-master extrait.

  3. Accédez au répertoire cloudml-samples-master > census > estimator. Les commandes de cette procédure doivent être exécutées à partir du répertoire estimator.

    cd cloudml-samples-master/census/estimator
    

Cloud Shell

  1. Pour télécharger le fichier ZIP contenant l'exemple AI Platform, saisissez la commande suivante :

    wget https://github.com/GoogleCloudPlatform/cloudml-samples/archive/master.zip
    
  2. Décompressez le fichier pour extraire le répertoire cloudml-samples-master.

    unzip master.zip
    
  3. Accédez au répertoire cloudml-samples-master > census > estimator. Les commandes de cette procédure doivent être exécutées à partir du répertoire estimator.

    cd cloudml-samples-master/census/estimator
    

Développer et valider votre application d'apprentissage en local

Avant d'exécuter votre application d'apprentissage dans le cloud, exécutez-la en local. Comme les environnements locaux fournissent un flux de travail de développement et de validation efficace, vous pouvez créer rapidement des itérations. En outre, le débogage des applications en local ne vous coûtera rien, car vous n'utilisez pas de ressources cloud pour cela.

Obtenir vos données d'apprentissage

Les fichiers de données pertinents, adult.data et adult.test, sont hébergés dans un bucket Cloud Storage public. Pour les besoins de cet exemple, utilisez les versions présentes sur Cloud Storage, qui ont été nettoyées de manière simple, au lieu des données sources d'origine. Pour en savoir plus, consultez la section À propos des données ci-dessous.

Vous pouvez consulter ces fichiers de données directement sur Cloud Storage ou les copier dans votre environnement local. Pour les besoins de cet exemple, vous allez télécharger les échantillons de données pour l'apprentissage local, puis les importer dans votre bucket Cloud Storage pour l'apprentissage cloud.

  1. Téléchargez les données dans un répertoire de fichiers local, puis définissez les variables qui désignent les fichiers de données téléchargés.

    mkdir data
    gsutil -m cp gs://cloud-samples-data/ml-engine/census/data/* data/
    
  2. Définissez les variables TRAIN_DATA et EVAL_DATA sur vos chemins d'accès aux fichiers locaux. Par exemple, les commandes suivantes définissent les variables sur des chemins d'accès locaux :

    TRAIN_DATA=$(pwd)/data/adult.data.csv
    EVAL_DATA=$(pwd)/data/adult.test.csv
    

Les données sont stockées au format CSV (valeurs séparées par une virgule), comme indiqué par l'aperçu suivant du fichier adult.data :

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K
38, Private, 215646, HS-grad, 9, Divorced, Handlers-cleaners, Not-in-family, White, Male, 0, 0, 40, United-States, <=50K
53, Private, 234721, 11th, 7, Married-civ-spouse, Handlers-cleaners, Husband, Black, Male, 0, 0, 40, United-States, <=50K
...

Installer des dépendances

macOS

Pour installer TensorFlow en local, nous vous recommandons d'utiliser un environnement virtuel. Pour ce faire, consultez les consignes pour :

Si vous connaissez bien Docker, vous pouvez suivre ce tutoriel en utilisant un conteneur TensorFlow. Affichez les consignes pour installer TensorFlow avec Docker.

L'exemple fournit un fichier requirements.txt que vous pouvez utiliser pour installer les dépendances nécessaires au projet. Dans votre environnement virtuel, saisissez la commande suivante :

  pip install --user -r ../requirements.txt

Cette commande installe TensorFlow 1.10, qui est la version utilisée dans le tutoriel.

Cloud Shell

Même si TensorFlow est installé sur Cloud Shell, vous devez exécuter le fichier requirements.txt de l'exemple pour vérifier que vous utilisez bien la version de TensorFlow requise.

  pip install --user -r ../requirements.txt

Cette commande installe TensorFlow 1.10, qui est la version utilisée dans le tutoriel.

Exécuter une tâche d'apprentissage en local

Une tâche d'apprentissage locale charge votre programme d'apprentissage Python, puis démarre un processus d'apprentissage dans un environnement semblable à celui d'une tâche d'apprentissage AI Platform dans le cloud en conditions réelles.

  1. Spécifiez un répertoire de sortie, puis définissez une variable MODEL_DIR. La commande suivante définit MODEL_DIR sur une valeur output.

    MODEL_DIR=output
    
  2. Nous vous recommandons de supprimer le contenu du répertoire de sortie au cas où des données provenant d'un précédent apprentissage subsisteraient. La commande suivante supprime toutes les données dans le répertoire output.

    rm -rf $MODEL_DIR/*
    
  3. Pour exécuter votre apprentissage en local, exécutez la commande suivante :

    gcloud ml-engine local train \
        --module-name trainer.task \
        --package-path trainer/ \
        --job-dir $MODEL_DIR \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100
    

Par défaut, la journalisation détaillée est désactivée. Vous pouvez l'activer en définissant le tag --verbosity sur DEBUG. Cette activation vous sera expliquée dans un prochain exemple.

Inspecter les journaux de résumé à l'aide de TensorBoard

Pour afficher les résultats de l'évaluation, vous pouvez utiliser l'outil de visualisation appelé TensorBoard. Il vous permet de visualiser votre graphe TensorFlow, de tracer des métriques quantitatives sur l'exécution de votre graphe, ainsi que d'afficher des données supplémentaires comme des images qui transitent par le graphe. TensorBoard est fourni avec l'installation de TensorFlow.

Suivez la procédure ci-dessous pour lancer TensorBoard et le renvoyer, pendant et après l'exécution, aux journaux de résumé produits pendant l'apprentissage.

macOS

  1. Lancez TensorBoard :

    tensorboard --logdir=$MODEL_DIR
    
  2. Une fois TensorBoard lancé, vous pouvez y accéder depuis votre navigateur à l'adresse http://localhost:6006.

Cloud Shell

  1. Lancez TensorBoard :

    tensorboard --logdir=$MODEL_DIR --port=8080
    
  2. Dans le menu Web Preview (Aperçu sur le Web) en haut de la ligne de commande, sélectionnez "Preview on port 8080" (Prévisualiser sur le port 8080).

Cliquez sur Accuracy (Précision) pour afficher les représentations graphiques relatives à l'évolution de la précision au fur et à mesure de la progression de votre tâche.

Graphes de précision Tensorboard

Vous pouvez fermer TensorBoard à tout moment en appuyant sur les touches ctrl+c dans la ligne de commande.

Exécuter une tâche d'apprentissage locale en mode distribué

Vous pouvez vérifier si votre modèle fonctionne avec l'environnement d'exécution distribué d'AI Platform en exécutant une tâche d'entraînement locale avec l'indicateur --distributed.

  1. Spécifiez un répertoire de sortie et définissez la variable MODEL_DIR à nouveau. La commande suivante définit MODEL_DIR sur une valeur output-dist.

    MODEL_DIR=output-dist
    
  2. Supprimez le contenu du répertoire output au cas où des données provenant d'un précédent apprentissage subsisteraient.

    rm -rf $MODEL_DIR/*
    
  3. Exécutez la commande local train à l'aide de l'option --distributed. Veillez à placer l'indicateur au-dessus du double tiret (--) qui sépare les arguments utilisateur des arguments de ligne de commande.

    gcloud ml-engine local train \
        --module-name trainer.task \
        --package-path trainer/ \
        --job-dir $MODEL_DIR \
        --distributed \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100
    

Inspecter les résultats

Les fichiers de sortie sont placés dans le répertoire spécifié par --job-dir, qui a été défini sur output-dist :

ls -R output-dist/

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

checkpoint
eval
events.out.tfevents.1488577094.<host-name>
export
graph.pbtxt
model.ckpt-1000.data-00000-of-00001
model.ckpt-1000.index
model.ckpt-1000.meta
model.ckpt-2.data-00000-of-00001
model.ckpt-2.index
model.ckpt-2.meta

output-dist//eval:
events.out.tfevents.<timestamp>.<host-name>
events.out.tfevents.<timestamp><host-name>
events.out.tfevents.<timestamp>.<host-name>

output-dist//export:
census

output-dist//export/census:
<timestamp>

output-dist//export/census/<timestamp>:
saved_model.pb
variables
...

Inspecter les journaux

Vous pouvez inspecter les journaux de résumé à l'aide de TensorBoard de la même manière que pour la tâche d'apprentissage à une seule instance. Cependant, vous devez modifier la valeur --logdir pour qu'elle corresponde au nom du répertoire de sortie utilisé pour le mode distribué.

macOS

  1. Lancez TensorBoard :

    tensorboard --logdir=$MODEL_DIR
    
  2. Une fois TensorBoard lancé, vous pouvez y accéder depuis votre navigateur à l'adresse http://localhost:6006.

Cloud Shell

  1. Lancez TensorBoard :

    tensorboard --logdir=$MODEL_DIR --port=8080
    
  2. Dans le menu Web Preview (Aperçu sur le Web) en haut de la ligne de commande, sélectionnez "Preview on port 8080" (Prévisualiser sur le port 8080).

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 s'il ne fait pas partie du projet servant à exécuter AI Platform, vous devez explicitement accorder l'accès aux comptes de service AI Platform.

  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 -mlengine :

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    BUCKET_NAME=${PROJECT_ID}-mlengine
  2. Vérifiez le nom de 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.

    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 :

    gsutil mb -l $REGION gs://$BUCKET_NAME

    Remarque : Servez-vous de la même région que celle où vous envisagez d'exécuter des tâches AI Platform. L'exemple est basé sur us-central1, car il s'agit de la région utilisée dans les instructions de démarrage.

Importez les fichiers de données dans votre bucket Cloud Storage.

  1. Utilisez gsutil pour copier les deux fichiers dans votre bucket Cloud Storage.

    gsutil cp -r data gs://$BUCKET_NAME/data
    
  2. Définissez les variables TRAIN_DATA et EVAL_DATA pour qu'elles désignent ces fichiers.

    TRAIN_DATA=gs://$BUCKET_NAME/data/adult.data.csv
    EVAL_DATA=gs://$BUCKET_NAME/data/adult.test.csv
    
  3. Utilisez de nouveau gsutil pour copier le fichier de test JSON test.json dans votre bucket Cloud Storage.

    gsutil cp ../test.json gs://$BUCKET_NAME/data/test.json
    
  4. Définissez la variable TEST_JSON pour qu'elle désigne ce fichier.

    TEST_JSON=gs://$BUCKET_NAME/data/test.json
    

Exécuter une tâche d'apprentissage à une seule instance dans le cloud

Avec une tâche d'apprentissage validée qui fonctionne en mode à une seule instance et en mode distribué, vous êtes maintenant prêt à utiliser une tâche d'apprentissage dans le cloud. Vous allez commencer par envoyer une requête pour une tâche d'apprentissage à une seule instance.

Pour exécuter une tâche d'apprentissage à une seule instance, utilisez le niveau d'évolutivité par défaut BASIC. Le démarrage de la requête initiale de la tâche peut prendre quelques minutes. Toutefois, les tâches suivantes seront exécutées plus rapidement. Cela permet des itérations rapides lors du développement et de la validation de votre tâche d'apprentissage.

  1. Sélectionnez pour l'exécution de l'application d'apprentissage initiale un nom qui la distingue des prochaines applications d'apprentissage. Par exemple, vous pouvez ajouter un nombre pour représenter l'itération.

    JOB_NAME=census_single_1
    
  2. Spécifiez un répertoire pour la sortie générée par AI Platform en définissant une variable OUTPUT_PATH à inclure lorsque vous envoyez les tâches d'entraînement et de prédiction. OUTPUT_PATH représente le chemin d'accès complet à l'emplacement Cloud Storage utilisé pour les points de contrôle, les résumés et les exportations du modèle. Vous pouvez utiliser la variable BUCKET_NAME définie précédemment.

    Nous vous recommandons d'utiliser le nom de la tâche comme répertoire de sortie. Par exemple, l'élément OUTPUT_PATH suivant désigne un répertoire nommé census_single_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Exécutez la commande suivante pour envoyer dans le cloud une tâche d'apprentissage qui n'utilise qu'un seul processus. Cette fois-ci, définissez le tag --verbosity sur DEBUG pour pouvoir inspecter la sortie de journalisation complète et récupérer les données de précision, de perte et d'autres mesures. La sortie contient également plusieurs autres messages d'avertissement que vous pouvez ignorer pour les besoins de cet exemple.

    gcloud ml-engine jobs submit training $JOB_NAME \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100 \
        --verbosity DEBUG
    

Vous pouvez suivre la progression de votre tâche d'entraînement en consultant le résultat de la ligne de commande ou sur la page AI Platform > Tâches de la console Google Cloud Platform.

Inspecter les résultats

Pour les apprentissages cloud, les résultats sont générés dans Cloud Storage. Dans cet exemple, les résultats sont enregistrés dans OUTPUT_PATH. Pour les répertorier, exécutez la commande suivante :

gsutil ls -r $OUTPUT_PATH

Les résultats devraient être semblables aux résultats de l'apprentissage local (ci-dessus).

Inspecter les journaux Stackdriver

Les journaux sont particulièrement utiles pour comprendre le comportement de votre code d'apprentissage sur le cloud. Lorsqu'AI Platform exécute une tâche d'entraînement, tous les flux stdout et stderr ainsi que les entrées de journalisation sont capturés. Ces journaux sont stockés dans Stackdriver Logging. Ils sont visibles pendant et après l'exécution.

Le moyen le plus simple de trouver les entrées de journaux correspondant à votre tâche consiste à sélectionner votre tâche sur la page AI Platform > Tâches de la console GCP, puis à cliquer sur "Afficher les journaux".

Si vous laissez l'option "Tous les journaux" sélectionnée, tous les journaux de tous les nœuds de calcul s'afficheront. Vous pouvez également sélectionner une tâche spécifique. master-replica-0 affiche un aperçu de l'exécution de la tâche du point de vue de l'instance maître.

Comme vous avez sélectionné la journalisation détaillée, vous pouvez inspecter la sortie de journalisation complète. Recherchez le terme accuracy dans les journaux :

Capture d'écran de la console Stackdriver Logging pour les tâches AI Platform

Si vous le souhaitez, vous pouvez afficher ces journaux dans votre terminal depuis la ligne de commande à l'aide de la commande suivante :

gcloud ml-engine jobs stream-logs $JOB_NAME

Consultez toutes les options pour gcloud ml-engine jobs stream-logs.

Inspecter les journaux de résumé à l'aide de TensorBoard

Vous pouvez inspecter le comportement de votre tâche d'apprentissage à l'aide de TensorBoard. Pour ce faire, démarrez l'outil et indiquez le chemin des journaux de résumé produits pendant l'apprentissage, pendant et après l'exécution.

Comme les programmes d'apprentissage écrivent des résumés directement dans un emplacement Cloud Storage, TensorBoard peut les lire automatiquement. Il n'est pas nécessaire d'effectuer une copie manuelle des fichiers d'événements.

macOS

  1. Lancez TensorBoard :

    tensorboard --logdir=$OUTPUT_PATH
    
  2. Une fois TensorBoard lancé, vous pouvez y accéder depuis votre navigateur à l'adresse http://localhost:6006.

Cloud Shell

  1. Lancez TensorBoard :

    tensorboard --logdir=$OUTPUT_PATH --port=8080
    
  2. Dans le menu Web Preview (Aperçu sur le Web) en haut de la ligne de commande, sélectionnez "Preview on port 8080" (Prévisualiser sur le port 8080).

Cliquez sur Accuracy (Précision) pour afficher les représentations graphiques relatives à l'évolution de la précision au fur et à mesure de la progression de votre tâche.

Vous pouvez fermer TensorBoard à tout moment en appuyant sur les touches ctrl+c dans la ligne de commande.

Exécuter une tâche d'apprentissage distribuée dans le cloud

Pour tirer parti de l'infrastructure évolutive de Google lors de l'exécution de tâches d'apprentissage, configurez votre tâche d'apprentissage pour qu'elle s'exécute en mode distribué.

Aucun changement de code n'est nécessaire pour exécuter ce modèle en tant que processus distribué dans AI Platform.

Pour exécuter une tâche distribuée, définissez --scale-tier sur n'importe quelle valeur supérieure au niveau de base. Pour en savoir plus sur ces niveaux, consultez la documentation relative aux niveaux d'évolutivité.

  1. Sélectionnez pour votre tâche d'apprentissage distribuée un nom qui la distingue des autres tâches d'apprentissage. Par exemple, vous pouvez utiliser dist pour représenter le fait qu'elle soit distribuée et un nombre pour représenter l'itération.

    JOB_NAME=census_dist_1
    
  2. Spécifiez OUTPUT_PATH pour inclure le nom de la tâche et ainsi ne pas utiliser par inadvertance les mêmes points de contrôle entre les tâches. Vous devrez peut-être redéfinir la valeur BUCKET_NAME si vous avez démarré une nouvelle session de ligne de commande depuis la dernière fois que vous l'avez définie. Par exemple, l'élément OUTPUT_PATH suivant désigne un répertoire nommé census-dist-1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Exécutez la commande suivante pour envoyer dans le cloud une tâche d'apprentissage qui utilise plusieurs nœuds de calcul. Notez que le démarrage de la tâche peut prendre quelques minutes.

    Placez --scale-tier au-dessus du double tiret (--) qui sépare les arguments utilisateur des arguments de ligne de commande. Par exemple, la commande suivante utilise un niveau d'évolutivité STANDARD_1 :

    gcloud ml-engine jobs submit training $JOB_NAME \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        --scale-tier STANDARD_1 \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --verbosity DEBUG  \
        --eval-steps 100
    

Vous pouvez suivre la progression de votre tâche d'entraînement en consultant le résultat de la ligne de commande ou sur la page AI Platform > Tâches de la console Google Cloud Platform.

Inspecter les journaux

Inspectez les journaux Stackdriver et les journaux de résumé de la même manière que pour la tâche d'apprentissage à une seule instance.

Pour consulter les journaux Stackdriver, vous pouvez sélectionner votre tâche sur la page AI Platform > Tâches de la console GCP, puis cliquer sur Afficher les journaux. Vous pouvez aussi utiliser la commande suivante dans votre terminal :

gcloud ml-engine jobs stream-logs $JOB_NAME

Pour TensorBoard, procédez comme suit :

macOS

  1. Lancez TensorBoard :

    tensorboard --logdir=$OUTPUT_PATH
    
  2. Une fois TensorBoard lancé, vous pouvez y accéder depuis votre navigateur à l'adresse http://localhost:6006.

Cloud Shell

  1. Lancez TensorBoard :

    tensorboard --logdir=$OUTPUT_PATH --port=8080
    
  2. Dans le menu Web Preview (Aperçu sur le Web) en haut de la ligne de commande, sélectionnez "Preview on port 8080" (Prévisualiser sur le port 8080).

Réglages d'hyperparamètres

AI Platform propose des réglages d'hyperparamètres pour vous aider à optimiser la précision des prédictions de votre modèle. L'exemple de recensement stocke les paramètres de configuration des hyperparamètres dans un fichier YAML nommé hptuning_config.yaml et inclut ce fichier dans la requête d'apprentissage à l'aide de la variable --config.

  1. Sélectionnez un nouveau nom de tâche et créez une variable qui référence le fichier de configuration.

    HPTUNING_CONFIG=../hptuning_config.yaml
    JOB_NAME=census_core_hptune_1
    TRAIN_DATA=gs://$BUCKET_NAME/data/adult.data.csv
    EVAL_DATA=gs://$BUCKET_NAME/data/adult.test.csv
    
  2. Spécifiez OUTPUT_PATH pour inclure le nom de la tâche et ainsi ne pas utiliser par inadvertance les mêmes points de contrôle entre les tâches. Vous devrez peut-être redéfinir la valeur BUCKET_NAME si vous avez démarré une nouvelle session de ligne de commande depuis la dernière fois que vous l'avez définie. Par exemple, l'élément OUTPUT_PATH suivant désigne un répertoire nommé census_core_hptune_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Exécutez la commande suivante pour envoyer une tâche d'apprentissage qui utilise non seulement plusieurs nœuds de calcul, mais également les réglages d'hyperparamètres.

    gcloud ml-engine jobs submit training $JOB_NAME \
        --stream-logs \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --config $HPTUNING_CONFIG \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        --scale-tier STANDARD_1 \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --verbosity DEBUG  \
        --eval-steps 100
    

Pour en savoir plus sur ces réglages, consultez la page Présentation des réglages d'hyperparamètres.

Déployer un modèle pour appuyer la prédiction

  1. Choisissez un nom pour votre modèle. Celui-ci doit commencer par une lettre et ne contenir que des lettres, des chiffres et des traits de soulignement. Exemple :

    MODEL_NAME=census
    
  2. Créez un modèle AI Platform :

    gcloud ml-engine models create $MODEL_NAME --regions=$REGION
    
  3. Sélectionnez les résultats de la tâche à utiliser. L'exemple suivant utilise la tâche nommée census_dist_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/census_dist_1
    
  4. Recherchez le chemin d'accès complet des binaires de votre modèle éduqué et exporté :

    gsutil ls -r $OUTPUT_PATH/export
    
  5. Trouvez un répertoire nommé $OUTPUT_PATH/export/census/<timestamp>, puis copiez le chemin de ce répertoire (sans le signe ":" à la fin) et définissez la variable d'environnement MODEL_BINARIES sur sa valeur. Exemple :

    MODEL_BINARIES=gs://$BUCKET_NAME/census_dist_1/export/census/1487877383942/

    $BUCKET_NAME est le nom de votre bucket Cloud Storage et census_dist_1 est le répertoire de sortie.

  6. Exécutez la commande suivante pour créer une version v1 :

    gcloud ml-engine versions create v1 \
        --model $MODEL_NAME \
        --origin $MODEL_BINARIES \
        --runtime-version 1.10
    

Vous pouvez obtenir la liste de vos modèles en utilisant la commande models list.

gcloud ml-engine models list

Envoyer une requête de prédiction en ligne à un modèle déployé

Vous pouvez à présent envoyer des requêtes de prédiction à votre modèle. Par exemple, la commande suivante envoie une requête de prédiction en ligne à l'aide d'un fichier test.json téléchargé dans l'exemple de dépôt GitHub.

gcloud ml-engine predict \
    --model $MODEL_NAME \
    --version v1 \
    --json-instances ../test.json

La réponse inclut les probabilités de chaque libellé (> 50 K et <= 50 K) en fonction de l'entrée de données dans test.json, ce qui permet de déterminer si le revenu prévu est supérieur ou inférieur à 50 000 dollars.

La réponse est semblable à ce qui suit :

CLASSES       PROBABILITIES
[u'0', u'1']  [0.9969545602798462, 0.0030454816296696663]

Envoyer une tâche de prédiction par lots

Le service de prédiction par lots s'avère utile si vous avez de grandes quantités de données à traiter et n'avez aucune exigence en termes de latence pour la réception des résultats de prédiction. Ce service utilise le même format que la prédiction en ligne, mais nécessite le stockage des données dans Cloud Storage.

  1. Saisissez un nom pour la tâche.

    JOB_NAME=census_prediction_1
    
  2. Définissez le chemin de sortie.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Envoyez la tâche de prédiction.

    gcloud ml-engine jobs submit prediction $JOB_NAME \
        --model $MODEL_NAME \
        --version v1 \
        --data-format text \
        --region $REGION \
        --input-paths $TEST_JSON \
        --output-path $OUTPUT_PATH/predictions
    

Contrairement aux commandes précédentes, celle-ci renvoie immédiatement des résultats. Vérifiez la progression de la tâche et attendez que l'opération se termine :

gcloud ml-engine jobs describe $JOB_NAME

state: SUCCEEDED devrait s'afficher une fois la tâche terminée. Cette opération peut prendre plusieurs minutes. Vous pouvez également afficher les journaux de la tâche dans votre terminal en utilisant la commande suivante :

gcloud ml-engine jobs stream-logs $JOB_NAME

Vous pouvez également vérifier la progression sur la page AI Platform > Tâches de la console GCP.

Une fois la tâche achevée, vous pouvez réaliser les actions suivantes :

  • Lire le résumé des résultats

    gsutil cat $OUTPUT_PATH/predictions/prediction.results-00000-of-00001
    

    Des résultats semblables aux lignes suivantes devraient s'afficher :

    {"probabilities": [0.9962924122810364, 0.003707568161189556], "logits": [-5.593664646148682], "classes": 0, "logistic": [0.003707568161189556]}
    
  • Répertorier les autres fichiers générés par la tâche à l'aide de la commande gsutil ls

    gsutil ls -r $OUTPUT_PATH
    

Par rapport à la prédiction en ligne, la prédiction par lots :

  • est plus lente pour ce petit nombre d'instances, mais mieux adaptée à un grand nombre d'instances ;
  • peut renvoyer des résultats dans un ordre différent de celui des instances d'entrée. Notez que l'index numérique permet d'associer facilement chaque résultat à l'instance d'entrée correspondante. Cet index n'est en revanche pas nécessaire pour la prédiction en ligne puisque les résultats sont renvoyés dans le même ordre que les instances d'entrée d'origine.

Une fois les prédictions disponibles, la prochaine étape consiste généralement à réaliser l'ingestion de ces prédictions dans une base de données ou un pipeline de traitement de données.

Dans cet exemple, vous avez déployé le modèle avant d'exécuter la prédiction par lots. Toutefois, il est possible d'ignorer cette étape en spécifiant l'URI des binaires du modèle au moment de l'envoi de la tâche de prédiction par lots. En générant des prédictions à partir d'un modèle avant de le déployer, vous pouvez évaluer les performances du modèle sur différents ensembles de données d'évaluation pour vous assurer que le modèle répond à vos critères de déploiement.

Nettoyer

Si vous avez terminé l'analyse des résultats de vos sessions d'apprentissage et de prédiction, vous pouvez éviter que des frais supplémentaires ne soient facturés sur votre compte GCP pour les répertoires Cloud Storage utilisés dans cette procédure. Pour ce faire, procédez comme suit :

  1. Ouvrez une fenêtre de terminal (si aucune n'est déjà ouverte).

  2. Utilisez la commande "gsutil rm" avec l'indicateur "-r" pour supprimer le répertoire contenant votre tâche la plus récente :

    gsutil rm -r gs://$BUCKET_NAME/$JOB_NAME
    

Si l'opération réussit, la commande renvoie un message semblable à celui indiqué ci-dessous :

Removing gs://my-awesome-bucket/just-a-folder/cloud-storage.logo.png#1456530077282000...
Removing gs://my-awesome-bucket/...

Répétez la commande pour tous les autres répertoires créés pour cet exemple.

Si aucune autre donnée n'est stockée dans le bucket, vous pouvez également exécuter la commande gsutil rm -r sur le bucket lui-même.

À propos des données

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

Données du 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

Vous avez à présent terminé cette procédure de création d'un exemple de modèle AI Platform utilisant des données de recensement pour l'apprentissage et la prédiction. Vous avez validé la tâche d'apprentissage en local et l'avez exécutée dans le cloud sur une instance unique, puis en mode distribué. Vous avez ensuite utilisé les réglages d'hyperparamètres pour améliorer le modèle, puis utilisé le modèle pour obtenir des prédictions en ligne et par lots.

Pour continuer à découvrir AI Platform, consultez les ressources ci-dessous.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

AI Platform pour TensorFlow