Entraîner ResNet sur Cloud TPU (TF 2.x)

Ce tutoriel vous explique comment entraîner un modèle Keras Resnet sur Cloud TPU à l'aide de tf.distribute.TPUStrategy.

Si vous ne connaissez pas bien Cloud TPU, il vous est vivement recommandé de consulter le guide de démarrage rapide pour apprendre à créer un TPU et une VM Compute Engine.

Objectifs

  • Créer un bucket Cloud Storage pour stocker votre ensemble de données et la sortie du modèle
  • Préparez un ensemble de données fake_imagenet, semblable à l'ensemble de données ImageNet.
  • Exécuter la tâche d'entraînement
  • Vérifier les résultats

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

Avant de commencer ce tutoriel, vérifiez que votre projet Google Cloud est correctement configuré.

  1. Connectez-vous à votre compte Google.

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

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Ce tutoriel utilise des composants facturables de Google Cloud. Consultez la grille tarifaire de Cloud TPU pour estimer vos coûts. Veillez à nettoyer les ressources que vous avez créées lorsque vous avez terminé, afin d'éviter des frais inutiles.

Configurer vos ressources

Cette section fournit des informations sur la configuration des buckets Cloud Storage, des VM et des ressources Cloud TPU pour les tutoriels.

  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 compte de service pour le projet Cloud TPU.

    gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID
    

    La commande renvoie un compte de service Cloud TPU au format suivant :

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    

  5. Créez un bucket Cloud Storage à l'aide de la commande suivante :

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -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. L'outil ctpu up utilisé dans ce tutoriel définit les autorisations par défaut pour le compte de service Cloud TPU que vous avez configuré à l'étape précédente. Si vous souhaitez utiliser des autorisations plus précises, vérifiez les autorisations de niveau d'accès.

    L'emplacement du bucket doit être situé dans la même région que votre Compute Engine (VM) et votre nœud Cloud TPU.

  6. Lancez la ressource Compute Engine qui utilise la commande ctpu up.

    ctpu up --zone=europe-west4-a \
     --vm-only \
     --name=resnet-tutorial \
     --disk-size-gb=300 \
     --machine-type=n1-standard-16 \
     --tf-version=2.3.1

    Description des options de commande

    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    vm-only
    Pour créer une VM uniquement. Par défaut, la commande ctpu up crée une VM et un Cloud TPU.
    name
    Nom de la ressource Cloud TPU à créer.
    disk-size-gb
    Taille du disque dur en Go de la VM créée par la commande ctpu up.
    machine-type
    Type de machine de la VM Compute Engine à créer.
    tf-version
    La version de Tensorflow que ctpu installe sur la VM.

    Pour plus d'informations sur l'utilitaire CTPU, consultez la section Référence CTPU.

  7. Lorsque vous y êtes invité, appuyez sur y pour créer vos ressources Cloud TPU.

    .

    Une fois 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 resnet-tutorial --zone=europe-west4-a
    

    À mesure que vous appliquez ces instructions, exécutez chaque commande commençant par (vm)$ dans votre instance Compute Engine.

Définir des variables de bucket Cloud Storage

Configurez les variables d'environnement suivantes en remplaçant bucket-name par le nom de votre bucket Cloud Storage :

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/resnet-2x
(vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
(vm)$ export PYTHONPATH="$PYTHONPATH:/usr/share/models/"

L'application d'entraînement s'attend à ce que vos données d'entraînement soient accessibles dans Cloud Storage. Elle exploite également le bucket Cloud Storage pour stocker des points de contrôle lors de l'entraînement.

Entraîner et évaluer le modèle ResNet avec fake_imagenet

ImageNet est une base de données d'images. Les images de la base de données sont organisées hiérarchiquement, chaque nœud de cette hiérarchie étant représenté par des centaines de milliers d'images.

Ce tutoriel utilise une version de démonstration de l'ensemble de données complet ImageNet, appelée fake_imagenet. Cette version de démonstration vous permet de tester le tutoriel tout en réduisant les conditions de stockage et le temps généralement nécessaires à l'exécution d'un modèle par rapport à la base de données complète ImageNet.

L'ensemble de données fake_imagenet se trouve à cet emplacement sur Cloud Storage :

gs://cloud-tpu-test-datasets/fake_imagenet

Notez que l'ensemble de données fake_imagenet n'est utile que pour comprendre comment utiliser un Cloud TPU et valider les performances de bout en bout. La précision et le modèle enregistré ne sont pas représentatifs.

Pour plus d'informations sur le téléchargement et le traitement de l'ensemble de données complet ImageNet, consultez la page Télécharger, prétraiter et importer l'ensemble de données ImageNet.

  1. Lancez une ressource Cloud TPU à l'aide de l'utilitaire ctpu.

    (vm)$ ctpu up --tpu-only \
     --tpu-size=v3-8  \
     --name=resnet-tutorial \
     --zone=europe-west4-a \
     --tf-version=2.3.1
    

    Description des options de commande

    tpu-only
    Crée le Cloud TPU sans créer de VM. Par défaut, la commande ctpu up crée une VM et un Cloud TPU.
    tpu-size
    Type du Cloud TPU à créer.
    name
    Nom de la ressource Cloud TPU à créer.
    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    tf-version
    La version de Tensorflow que ctpu installe sur la VM.

    Pour plus d'informations sur l'utilitaire CTPU, consultez la section Référence CTPU.

  2. Définissez la variable de nom Cloud TPU. Il s'agit du nom que vous avez spécifié avec le paramètre --name sur ctpu up ou du nom d'utilisateur par défaut :

    (vm)$ export TPU_NAME=resnet-tutorial
    
  3. Le script d'entraînement ResNet nécessite un package supplémentaire. Installez-le maintenant :

    (vm)$ sudo pip3 install tensorflow-model-optimization>=0.1.3
    
  4. Accédez au répertoire du modèle ResNet-50 :

    (vm)$ cd /usr/share/models/official/vision/image_classification/resnet/
    
  5. Exécutez le script d'entraînement. Cette méthode utilise un ensemble de données fake_imagenet et entraîne ResNet pour une époque.

    (vm)$ python3 resnet_ctl_imagenet_main.py \
     --tpu=${TPU_NAME} \
     --model_dir=${MODEL_DIR} \
     --data_dir=${DATA_DIR} \
     --batch_size=1024 \
     --steps_per_loop=500 \
     --train_epochs=1 \
     --use_synthetic_data=false \
     --dtype=fp32 \
     --enable_eager=true \
     --enable_tensorboard=true \
     --distribution_strategy=tpu \
     --log_steps=50 \
     --single_l2_loss_op=true \
     --use_tf_function=true
    

    Description des options de commande

    tpu
    Nom de votre TPU.
    model_dir
    Spécifie le répertoire dans lequel sont stockés les points de contrôle et les résumés lors de l'entraînement du modèle. Si ce dossier est absent, le programme le crée. Lorsque vous utilisez un Cloud TPU, le répertoire model_dir doit être un chemin d'accès à Cloud Storage (gs://...). Vous pouvez réutiliser un dossier existant pour charger les données de point de contrôle actuelles et stocker des points de contrôle supplémentaires tant que les points de contrôle précédents ont été créés avec un TPU de la même taille et la même version de TensorFlow.
    data_dir
    Chemin d'accès Cloud Storage de l'entrée d'entraînement. Dans cet exemple, il est défini sur l'ensemble de données fake_imagenet.
    batch_size
    Taille de lot d'entraînement.
    steps_per_loop
    Nombre d'étapes d'entraînement à exécuter avant d'enregistrer l'état dans le processeur. Le traitement d'un lot d'exemples est l'une des étapes d'entraînement. Cela inclut à la fois une propagation avant et une rétropropagation.
    train_epochs
    Nombre d'entraînements du modèle utilisant l'ensemble de données complet.
    use_synthetic_data
    Indique si les données synthétiques doivent être utilisées pour l'entraînement.
    dtype
    Type de données à utiliser pour l'entraînement.
    enable_eager
    Active l'exécution eager de TensorFlow.
    enable_tensorboard
    Active TensorBoard.
    distribution_strategy
    Pour entraîner le modèle ResNet sur un TPU, définissez distribution_strategy sur tpu.
    log_steps
    Nombre d'étapes d'entraînement à effectuer avant la journalisation des informations de durée, telles que examples per second.
    single_l2_loss_op
    Calcule la perte L2_loss sur les pondérations concaténées, au lieu d'utiliser la perte L2 par couche.
    use_tf_function
    Encapsule les étapes d'entraînement et de test dans un tf.function.

Cela entraînera ResNet pendant une époque et se terminera sur un nœud TPU v3-8 en moins de 10 minutes. À la fin de l'entraînement, un résultat semblable à ce qui suit s'affiche :

I1107 20:28:57.561836 140033625347520 resnet_ctl_imagenet_main.py:222] Training 1 epochs, each epoch has 1251 steps, total steps: 1251; Eval 48 steps
I1107 20:34:09.638025 140033625347520 resnet_ctl_imagenet_main.py:358] Training loss: 0.6292637, accuracy: 0.99680257 at epoch 1
I1107 20:34:21.682796 140033625347520 resnet_ctl_imagenet_main.py:372] Test loss: 3.8977659, accuracy: 0.0% at epoch: 1
I1107 20:34:22.028973 140033625347520 resnet_ctl_imagenet_main.py:392]
Run stats:
{'train_loss': 0.6292637, 'train_acc': 0.99680257, 'eval_acc': 0.0, 'step_timestamp_log':
['BatchTimestamp <batch_index: 1, timestamp: 1573158554.11>'],
'train_finish_time': 1573158861.683073, 'eval_loss': 3.8977659>}

Pour entraîner le modèle ResNet jusqu'à la convergence, exécutez-la pendant 90 époques, comme indiqué dans le script suivant. L'entraînement et l'évaluation sont effectués ensemble. Chaque époque comporte 1 251 étapes pour un total de 112 590 étapes d'entraînement et 48 étapes d'évaluation.

(vm)$ python3 resnet_ctl_imagenet_main.py \
    --tpu=${TPU_NAME} \
    --model_dir=${MODEL_DIR} \
    --data_dir=${DATA_DIR} \
    --batch_size=1024 \
    --steps_per_loop=500 \
    --train_epochs=90 \
    --use_synthetic_data=false \
    --dtype=fp32 \
    --enable_eager=true \
    --enable_tensorboard=true \
    --distribution_strategy=tpu \
    --log_steps=50 \
    --single_l2_loss_op=true \
    --use_tf_function=true

Description des options de commande

tpu
Nom de votre TPU.
model_dir
Spécifie le répertoire dans lequel les points de contrôle et les résumés sont stockés lors de l'entraînement du modèle. Si ce dossier n'existe pas, le programme va le créer. Lorsque vous utilisez Cloud TPU, le chemin model_dir doit être un chemin d'accès Cloud Storage (gs://...). Vous pouvez réutiliser un dossier existant pour charger les données de point de contrôle actuelles et stocker des points de contrôle supplémentaires si les points de contrôle précédents ont été créés à l'aide d'un Cloud TPU de la même taille et de la même version de TensorFlow.
data_dir
Chemin d'accès Cloud Storage de l'entrée d'entraînement. Dans cet exemple, il est défini sur l'ensemble de données fake_imagenet.
batch_size
Taille de lot d'entraînement.
steps_per_loop
Nombre d'étapes d'entraînement à exécuter avant d'enregistrer l'état dans le processeur. Une étape d'entraînement correspond au traitement d'un lot d'exemples. Cela inclut à la fois une propagation avant et une rétropropagation.
train_epochs
Nombre d'entraînements du modèle utilisant l'ensemble de données complet.
use_synthetic_data
Indique si les données synthétiques doivent être utilisées pour l'entraînement.
dtype
Type de données à utiliser pour l'entraînement.
enable_eager
Active l'exécution eager de TensorFlow.
enable_tensorboard
Active TensorBoard.
distribution_strategy
Pour entraîner le modèle ResNet sur un TPU, définissez distribution_strategy sur tpu.
log_steps
Nombre d'étapes d'entraînement à effectuer avant la journalisation des informations de durée, telles que examples per second.
single_l2_loss_op
Calcule la perte L2_loss sur les pondérations concaténées, au lieu d'utiliser la perte L2 par couche.
use_tf_function
Encapsule les étapes d'entraînement et de test dans un tf.function.

L'entraînement et l'évaluation ayant été effectués sur l'ensemble de données factice fake_dataset, les résultats de sortie ne reflètent pas le résultat réel qui apparaîtrait si l'entraînement et l'évaluation étaient effectués sur un ensemble de données réel.

Vous pouvez maintenant terminer ce tutoriel et nettoyer vos ressources GCP. Vous pouvez également choisir d'explorer plus avant l'exécution du modèle dans un pod Cloud TPU.

Mise à l'échelle de votre modèle avec les pods Cloud TPU

Vous pouvez obtenir des résultats plus rapidement en adaptant votre modèle aux pods Cloud TPU. Le modèle ResNet-50 est entièrement compatible et peut fonctionner avec les tranches de pod suivantes :

  • v2-32
  • v3-32

Avec les pods Cloud TPU, l'entraînement et l'évaluation sont effectués ensemble.

Entraîner avec les pods Cloud TPU

  1. Supprimez la ressource Cloud TPU que vous avez créée pour entraîner le modèle sur un seul appareil.

    (vm)$ ctpu delete --zone=europe-west4-a \
     --tpu-only \
     --name=resnet-tutorial

    Description des options de commande

    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    tpu-only
    Supprime le Cloud TPU.
    name
    Nom de la ressource Cloud TPU à créer.
    disk-size-gb
    Taille du disque dur en Go de la VM créée par la commande ctpu up.
  2. Une fois le Cloud TPU supprimé, créez un nouveau pod Cloud TPU. Exécutez la commande ctpu up à l'aide du paramètre tpu-size pour spécifier la tranche de pod que vous souhaitez utiliser. Par exemple, la commande suivante utilise une tranche de pod v3-32.

    (vm)$ ctpu up --zone=europe-west4-a \
    --tpu-only \
    --name=resnet-tutorial \
    --tpu-size=v3-32
    

    Description des options de commande

    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    tpu-only
    Crée uniquement le Cloud TPU. Par défaut, la commande ctpu up crée à la fois une VM et un Cloud TPU.
    name
    Nom de la ressource Cloud TPU à créer.
    tpu-size
    Type du Cloud TPU à créer.

    Pour plus d'informations sur l'utilitaire CTPU, consultez la section Référence CTPU.

  3. Définissez certaines variables d'environnement requises :

    (vm)$ export TPU_NAME=resnet-tutorial
    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/resnet-2x-pod
    
  4. Accédez au répertoire du script :

    (vm)$ cd /usr/share/models/official/vision/image_classification/resnet
    
  5. Entraîner le modèle

    (vm)$ python3 resnet_ctl_imagenet_main.py \
      --tpu=${TPU_NAME} \
      --model_dir=${MODEL_DIR} \
      --data_dir=${DATA_DIR} \
      --batch_size=4096 \
      --steps_per_loop=500 \
      --train_epochs=1 \
      --use_synthetic_data=false \
      --dtype=fp32 \
      --enable_eager=true \
      --enable_tensorboard=true \
      --distribution_strategy=tpu \
      --log_steps=50 \
      --single_l2_loss_op=true \
      --use_tf_function=true
     

    Description des options de commande

    tpu
    Nom de votre TPU.
    model_dir
    Spécifie le répertoire dans lequel les points de contrôle et les résumés sont stockés lors de l'entraînement du modèle. Si ce dossier n'existe pas, le programme le crée. Lorsque vous utilisez Cloud TPU, le model_dir doit être un chemin Cloud Storage (gs://...). Vous pouvez réutiliser un dossier existant pour charger les données de point de contrôle actuelles et stocker des points de contrôle supplémentaires tant que les précédents ont été créés avec un Cloud TPU de la même taille et la même version de Tensorflow.
    data_dir
    Chemin d'accès Cloud Storage de l'entrée d'entraînement. Dans cet exemple, il est défini sur l'ensemble de données fake_imagenet.
    batch_size
    Taille de lot d'entraînement.
    steps_per_loop
    Nombre d'étapes d'entraînement à exécuter avant d'enregistrer l'état dans le processeur. Le traitement d'un lot d'exemples est l'une des étapes d'entraînement. Cela inclut à la fois une propagation avant et une rétropropagation.
    train_epochs
    Nombre d'entraînements du modèle utilisant l'ensemble de données complet.
    use_synthetic_data
    Indique si les données synthétiques doivent être utilisées pour l'entraînement.
    dtype
    Type de données à utiliser pour l'entraînement.
    enable_eager
    Active l'exécution eager de TensorFlow.
    enable_tensorboard
    Active TensorBoard.
    distribution_strategy
    Pour entraîner le modèle ResNet sur un TPU, définissez distribution_strategy sur tpu.
    log_steps
    Nombre d'étapes d'entraînement à effectuer avant la journalisation des informations de durée, telles que examples per second.
    single_l2_loss_op
    Calcule la perte L2_loss sur les pondérations concaténées, au lieu d'utiliser la perte L2 par couche.
    use_tf_function
    Encapsule les étapes d'entraînement et de test dans un tf.function.

La procédure entraîne le modèle sur l'ensemble de données fake_imagenet sur une époque (312 pas d'entraînement et 12 pas d'évaluation). Cet entraînement dure environ 2 minutes sur un Cloud TPU v3-32. Une fois l'entraînement et l'évaluation terminés, un message semblable au suivant s'affiche :

1107 22:45:19.821746 140317155378624 resnet_ctl_imagenet_main.py:358] Training loss: 0.22576721, accuracy: 0.838141 at epoch 1
I1107 22:45:33.892045 140317155378624 resnet_ctl_imagenet_main.py:372] Test loss: 0.26673648, accuracy: 0.0% at epoch: 1
I1107 22:45:34.851322 140317155378624 resnet_ctl_imagenet_main.py:392] Run stats:
{'train_loss': 0.22576721, 'train_acc': 0.838141, 'eval_acc': 0.0, 'step_timestamp_log': ['BatchTimestamp<batch_index: 1, timestamp: 1573166574.67>'], 'train_finish_time': 1573166733.892282, 'eval_loss': 0.26673648}

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 l'instance Compute Engine, si vous ne l'avez pas déjà fait :

    (vm)$ exit
    

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

  2. Dans votre environnement Cloud Shell, exécutez ctpu delete avec les options --zone que vous avez utilisées lors de la configuration de la VM Compute Engine et du Cloud TPU. Cela supprime à la fois votre VM et votre Cloud TPU.

    $ ctpu delete --zone=europe-west4-a \
      --name=resnet-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 :

    $ ctpu status --zone=europe-west4-a
    2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
    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 RESNET à 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.

  • Découvrez comment entraîner et évaluer avec vos propres données, au lieu des ensembles de données fake_imagenet ou ImageNet, en suivant le tutoriel de conversion des ensembles de données. Le tutoriel explique comment utiliser l'exemple de script de conversion de données de classification d'images pour convertir un ensemble de données brut au format TFRecords, utilisable par les modèles Tensorflow de Cloud TPU.
  • Exécutez un colab Cloud TPU qui montre comment exécuter un modèle de classification d'images à l'aide de vos propres données d'image.
  • Découvrez les autres tutoriels Cloud TPU.
  • Apprenez à utiliser les outils de surveillance TPU dans TensorBoard.
  • Découvrez comment entraîner ResNet avec Cloud TPU et GKE.