Exécuter Deeplab v3 sur Cloud TPU

Ce tutoriel vous explique comment entraîner le modèle Deeplab-v3 sur Cloud TPU.

Les instructions ci-dessous supposent que vous savez comment exécuter un modèle sur Cloud TPU. Si vous débutez avec Cloud TPU, consultez le guide de démarrage rapide pour en savoir plus.

Si vous prévoyez d'effectuer l'entraînement sur une tranche de pod TPU, consultez la section Entraîner sur des pods TPU pour comprendre les modifications de paramètres requises pour les tranches de pods.

Il s'agit d'un modèle de segmentation sémantique d'images. Les modèles de segmentation sémantique d'images se concentrent sur l'identification et la localisation de plusieurs objets dans une seule image. Ce type de modèle est fréquemment utilisé dans les applications de machine learning (par exemple : pour la conduite autonome, le traitement d'images géospatiales et l'imagerie médicale).

Dans ce tutoriel, vous allez exécuter un modèle d'entraînement sur l'ensemble de données PASCAL VOC 2012. Pour en savoir plus sur cet ensemble de données, consultez la page d'accueil de PASCAL Visual Object Classes.

Objectifs

  • Créer un bucket Cloud Storage pour stocker votre ensemble de données et la sortie du modèle
  • Installez les packages requis.
  • Télécharger et convertir l'ensemble de données PASCAL VOC 2012
  • Entraîner le modèle Deeplab.
  • Évaluer le modèle Deeplab.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • Instance
  • Cloud TPU
  • Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Cette section fournit des informations sur la configuration du bucket Cloud Storage et d'une VM Compute Engine.

  1. Ouvrez une fenêtre Cloud Shell.

    Ouvrir Cloud Shell

  2. Créez une variable pour l'ID de votre projet.

    export PROJECT_ID=project-id
    
  3. Configurez l'outil de ligne de commande gcloud pour utiliser le projet dans lequel vous souhaitez créer Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    
  4. Créez un bucket Cloud Storage à l'aide de la commande suivante :

    gsutil mb -p ${PROJECT_ID} -c standard -l us-central1 -b on gs://bucket-name
    

    Ce bucket Cloud Storage stocke les données que vous utilisez pour entraîner votre modèle, ainsi que les résultats de l'entraînement.

    Pour que Cloud TPU puisse lire et écrire dans le bucket de stockage, le compte de service de votre projet doit disposer d'autorisations de lecture/écriture ou d'administrateur. Consultez la section sur les buckets de stockage pour savoir comment afficher et définir ces autorisations.

  5. Lancez une VM Compute Engine à l'aide de la commande ctpu up.

    $ ctpu up --zone=us-central1-b \
     --machine-type=n1-standard-8 \
     --vm-only \
     --tf-version=1.15.3 \
     --name=deeplab-tutorial
    
  6. La configuration que vous avez spécifiée apparaît. Saisissez y pour approuver ou n pour annuler.

  7. Une fois l'exécution de la commande ctpu up terminée, vérifiez que l'invite de l'interface système est passée de username@projectname à username@vm-name. Cette modification indique que vous êtes maintenant connecté à votre VM Compute Engine.

    gcloud compute ssh deeplab-tutorial --zone=us-central1-b
    

À mesure que vous appliquez ces instructions, exécutez chaque commande commençant par (vm)$ dans la fenêtre de session de la VM.

Installer des packages supplémentaires

Pour ce modèle, vous devez installer les packages supplémentaires suivants sur votre instance Compute Engine :

  • jupyter
  • matplotlib
  • PrettyTable
  • tf_slim
  (vm)$ pip3 install --user jupyter
  (vm)$ pip3 install --user matplotlib
  (vm)$ pip3 install --user PrettyTable
  (vm)$ pip3 install --user tf_slim
  1. Créez des variables d'environnement pour votre bucket de stockage et votre nom TPU.

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
    (vm)$ export TPU_NAME=deeplab-tutorial
    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/deeplab_data
    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/deeplab_model
    (vm)$ export PYTHONPATH=${PYTHONPATH}:/usr/share/models/research:/usr/share/models/research/slim
    

Préparer l'ensemble de données

  1. Télécharger et convertir l'ensemble de données PASCAL VOC 2012

    Ce modèle utilise l'ensemble de données PASCAL VOC 2012 pour l'entraînement et l'évaluation. Exécutez le script suivant pour télécharger l'ensemble de données et le convertir au format TFRecord de TensorFlow :

     (vm)$ bash /usr/share/models/research/deeplab/datasets/download_and_convert_voc2012.sh
    
  2. Télécharger le point de contrôle pré-entraîné

    Dans cette étape, vous téléchargez le point de contrôle pré-entraîné ResNet-101 modifié. Pour commencer, téléchargez le point de contrôle :

     (vm)$ wget http://download.tensorflow.org/models/resnet_v1_101_2018_05_04.tar.gz
    

    Procédez ensuite à l'extraction du contenu du fichier tar :

     (vm)$ tar -vxf resnet_v1_101_2018_05_04.tar.gz
    
  3. Importer des données sur le bucket Cloud Storage

    À ce stade, vous pouvez importer les données dans le bucket Cloud Storage que vous avez créé précédemment :

    (vm)$ gsutil -m cp -r pascal_voc_seg/tfrecord ${DATA_DIR}/tfrecord
    
    (vm)$ gsutil -m cp -r resnet_v1_101 ${DATA_DIR}
    

Créer une ressource Cloud TPU

Exécutez la commande suivante pour créer un Cloud TPU.

  (vm)$ ctpu up --tpu-only \
  --tf-version=1.15.3 \
  --tpu-size=v3-8 \
  --name=deeplab-tutorial

Entraîner le modèle

Exécutez le script d'entraînement pour 2 000 étapes d'entraînement. Cette opération prend environ 20 minutes. Pour exécuter une conversion, supprimez l'option --train_steps=2000 de la ligne de commande du script d'entraînement. Le processus de convergence prend environ 10 heures.

(vm)$ python3 /usr/share/tpu/models/experimental/deeplab/main.py \
--mode='train' \
--num_shards=8 \
--alsologtostderr=true \
--model_dir=${MODEL_DIR} \
--dataset_dir=${DATA_DIR}/tfrecord \
--init_checkpoint=${DATA_DIR}/resnet_v1_101/model.ckpt \
--model_variant=resnet_v1_101_beta \
--image_pyramid=1. \
--aspp_with_separable_conv=false \
--multi_grid=1 \
--multi_grid=2 \
--multi_grid=4 \
--decoder_use_separable_conv=false \
--train_split='train' \
--train_steps=2000 \
--tpu=${TPU_NAME}

Évaluer le modèle sur un appareil Cloud TPU

Une fois l'entraînement terminé, vous pouvez procéder à l'évaluation du modèle. Pour ce faire, remplacez la valeur train de l'indicateur --mode par eval :

(vm)$ python3 /usr/share/tpu/models/experimental/deeplab/main.py \
--mode='eval' \
--num_shards=8 \
--alsologtostderr=true \
--model_dir=${MODEL_DIR} \
--dataset_dir=${DATA_DIR}/tfrecord \
--init_checkpoint=${DATA_DIR}/resnet_v1_101/model.ckpt \
--model_variant=resnet_v1_101_beta \
--image_pyramid=1. \
--aspp_with_separable_conv=false \
--multi_grid=1 \
--multi_grid=2 \
--multi_grid=4 \
--decoder_use_separable_conv=false \
--train_split='train' \
--tpu=${TPU_NAME}

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Déconnectez-vous de la VM Compute Engine :

    (vm)$ exit
    

    Votre invite devrait maintenant être username@projectname, indiquant que vous êtes dans Cloud Shell.

  2. Dans Cloud Shell, exécutez la commande ctpu delete avec l'option --zone utilisée lors de votre configuration Cloud TPU pour supprimer votre VM Compute Engine et votre Cloud TPU :

    $ ctpu delete --zone=us-central1-b \
      --name=deeplab-tutorial
    
  3. Exécutez ctpu status pour vérifier qu'il ne reste aucune instance allouée afin d'éviter des frais inutiles liés à l'utilisation des ressources TPU. La suppression peut prendre plusieurs minutes. Si vous n'avez plus d'instances allouées, une réponse de ce type s'affiche :

    2018/04/28 16:16:23 WARNING: Setting zone to "us-central1-b"
    No instances currently exist.
            Compute Engine VM:     --
            Cloud TPU:             --
    
  4. Exécutez gsutil comme indiqué, en remplaçant bucket-name par le nom du bucket Cloud Storage que vous avez créé pour ce tutoriel :

    $ gsutil rm -r gs://bucket-name
    

Étape suivante

Dans ce tutoriel, vous avez entraîné le modèle DeepLab-v3 à l'aide d'un exemple d'ensemble de données. Les résultats de cet entraînement ne sont pas utilisables pour l'inférence dans la plupart des cas. Afin d'utiliser un modèle pour l'inférence, vous pouvez entraîner les données sur un ensemble de données accessible au public ou sur votre propre ensemble de données. Les modèles entraînés sur des appareils Cloud TPU nécessitent des ensembles de données au format TFRecord.

Vous pouvez utiliser l'exemple d'outil de conversion d'ensemble de données pour convertir un ensemble de données de classification d'images au format TFRecord. Si vous n'utilisez pas de modèle de classification d'images, vous devez convertir vous-même votre ensemble de données au format TFRecord. Pour en savoir plus, consultez la section TFRecord et tf.Example.

Réglages d'hyperparamètres

Pour améliorer les performances du modèle avec votre ensemble de données, vous pouvez régler ses hyperparamètres. Vous trouverez des informations sur les hyperparamètres communs à tous les modèles compatibles avec des TPU sur GitHub. Des informations sur les hyperparamètres spécifiques au modèle sont disponibles dans le code source de chaque modèle. Pour en savoir plus sur ces réglages, consultez les pages Présentation des réglages d'hyperparamètres, Utiliser le service de réglage d'hyperparamètres et Régler les hyperparamètres.

Inférence

Une fois que vous avez entraîné votre modèle, vous pouvez l'utiliser pour l'inférence (également appelée prédiction). AI Platform est une solution basée sur le cloud permettant de développer, d'entraîner et de déployer des modèles de machine learning. Une fois un modèle déployé, vous pouvez utiliser le service AI Platform Prediction.