Cette page a été traduite par l'API Cloud Translation.
Switch to English

Entraîner Mask R-CNN avec Cloud TPU et GKE

Ce tutoriel vous explique comment entraîner le modèle Mask RCNN sur Cloud TPU et GKE.

Objectifs

  • Créer un bucket Cloud Storage pour stocker votre ensemble de données et la sortie du modèle
  • Créez un cluster GKE pour gérer vos ressources Cloud TPU.
  • Télécharger une spécification de tâche Kubernetes décrivant les ressources nécessaires à l'entraînement de Mask RCNN avec TensorFlow sur Cloud TPU
  • Exécuter la tâche dans votre cluster GKE pour commencer à entraîner le modèle
  • Vérifiez les journaux et la sortie du modèle.

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

  1. Connectez-vous à votre compte Google.

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

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

    Accéder à la page de sélection du 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. Lorsque vous exploitez Cloud TPU avec GKE, votre projet utilise des composants facturables de Google Cloud. Consultez la grille tarifaire de Cloud TPU et celle de GKE pour estimer vos coûts, et suivez les instructions permettant de nettoyer les ressources lorsque vous n'en avez plus besoin.

  5. Activez les API requises pour ce tutoriel en ouvrant les liens suivants dans Cloud Console :

Créer un bucket Cloud Storage

Vous avez besoin d'un bucket Cloud Storage pour stocker les données permettant d'entraîner votre modèle et 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. Si vous souhaitez utiliser des autorisations plus précises, vérifiez les autorisations de niveau d'accès.

  1. Accédez à la page Cloud Storage de Cloud Console.

    Accéder à la page Cloud Storage

  2. Créez un bucket en spécifiant les options suivantes :

    • Un nom unique de votre choix
    • Classe de stockage par défaut : Regional
    • Choisissez où stocker vos données : region Emplacement : us-central1
    • Choisissez une classe de stockage par défaut pour vos données : Standard
    • Choisissez comment contrôler l'accès aux objets : Définir les autorisations au niveau de l'objet et au niveau du bucket

Créer un cluster sur GKE

Suivez les instructions ci-dessous pour configurer votre environnement et créer un cluster GKE compatible avec Cloud TPU, à l'aide de l'outil de ligne de commande gcloud.

  1. Ouvrez une fenêtre Cloud Shell.

    Ouvrir Cloud Shell

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

    La première fois que vous exécutez cette commande dans une nouvelle VM Cloud Shell, une page Authorize Cloud Shell s'affiche. Cliquez sur Authorize en bas de la page pour permettre à gcloud d'effectuer des appels d'API GCP avec vos identifiants.

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

  4. Autoriser Cloud TPU à accéder au bucket Cloud Storage

    Vous devez octroyer à votre Cloud TPU un accès en lecture/écriture à vos objets Cloud Storage. Pour ce faire, vous devez attribuer l'accès requis au compte de service utilisé par Cloud TPU. Suivez le guide pour attribuer l'accès à votre bucket de stockage .

  5. Spécifiez la zone dans laquelle vous prévoyez d'utiliser une ressource Cloud TPU. Pour cet exemple, choisissez la zone us-central1-b :

    $ gcloud config set compute/zone us-central1-b
    
  6. Exécutez la commande gcloud container clusters pour créer un cluster sur GKE compatible avec Cloud TPU. Notez que le cluster GKE et ses pools de nœuds doivent être créés dans une zone où Cloud TPU est disponible, comme décrit dans la section sur variables d'environnement ci-dessus. La commande suivante crée un cluster nommé tpu-models-cluster :

    $ gcloud container clusters create tpu-models-cluster \
    --cluster-version=1.13 \
    --scopes=cloud-platform \
    --enable-ip-alias \
    --enable-tpu \
    --machine-type=n1-standard-4
    

    Dans la commande ci-dessus :

    • --cluster-version=1.13 indique que le cluster utilise la dernière version de Kubernetes 1.16. Vous devez utiliser la version 1.13.4-gke.5 ou ultérieure.
    • --scopes=cloud-platform garantit que tous les nœuds du cluster ont accès à votre bucket Cloud Storage dans Google Cloud défini comme project-name ci-dessus. Le cluster et le bucket de stockage doivent toutefois appartenir au même projet. Notez que les pods héritent par défaut des champs d'application des nœuds sur lesquels ils sont déployés. Cet indicateur donne le champ d'application cloud-platform à tous les pods exécutés dans le cluster. Si vous souhaitez limiter l'accès pod par pod, consultez le guide GKE sur l'authentification avec des comptes de service.
    • --enable-ip-alias indique que le cluster utilise des plages d'adresses IP d'alias. Ceci est obligatoire pour pouvoir utiliser Cloud TPU sur GKE.
    • --enable-tpu indique que le cluster doit être compatible avec Cloud TPU.
    • machine-type=n1-standard-4 est requis pour exécuter cette tâche.

    Une fois l'exécution de la commande terminée, un message de confirmation semblable à celui-ci s'affiche :

    kubeconfig entry generated for tpu-models-cluster.
    NAME                LOCATION       MASTER_VERSION   MASTER_IP      MACHINE_TYPE   NODE_VERSION   NUM_NODES  STATUS
    tpu-models-cluster  us-central1-b  1.13.6-gke.5     35.232.204.86  n1-standard-4  1.13.6-gke.5   3          RUNNING
    

Traiter les données d'entraînement

La prochaine étape consiste à créer une tâche. Dans Google Kubernetes Engine, une tâche est un objet contrôleur qui représente un travail fini. La première tâche que vous devez créer télécharge et traite l'ensemble de données COCO utilisé pour l'entraînement du modèle Mask RCNN.

  1. Dans votre environnement shell, créez un fichier nommé download_and_preprocess_coco_k8s.yaml, comme illustré ci-dessous. Vous pouvez également télécharger ce fichier depuis GitHub.

    # Download and preprocess the COCO dataset.
    #
    # Instructions:
    #   1. Follow the instructions on https://cloud.google.com/tpu/docs/kubernetes-engine-setup
    #      to create a Kubernetes Engine cluster. The Job must be running at least
    #      on a n1-standard-4 machine.
    #   2. Change the environment variable DATA_BUCKET below to the path of the
    #      Google Cloud Storage bucket where you want to store the training data.
    #   3. Run `kubectl create -f download_and_preprocess_coco_k8s.yaml`.
    
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: download-and-preprocess-coco
    spec:
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: download-and-preprocess-coco
            # The official TensorFlow 1.13 TPU model image built from https://github.com/tensorflow/tpu/blob/r1.13/tools/docker/Dockerfile.
            image: gcr.io/tensorflow/tpu-models:r1.13
            command:
              - /bin/bash
              - -c
              - >
                DEBIAN_FRONTEND=noninteractive apt-get update &&
                cd /tensorflow_tpu_models/tools/datasets &&
                bash download_and_preprocess_coco.sh /scratch-dir &&
                gsutil -m cp /scratch-dir/*.tfrecord ${DATA_BUCKET}/coco &&
                gsutil cp /scratch-dir/raw-data/annotations/*.json ${DATA_BUCKET}/coco
            env:
              # [REQUIRED] Must specify the Google Cloud Storage location where the
              # COCO dataset will be stored.
            - name: DATA_BUCKET
              value: "gs://<my-data-bucket>/data/coco"
            volumeMounts:
            - mountPath: /scratch-dir
              name: scratch-volume
          volumes:
          - name: scratch-volume
            persistentVolumeClaim:
              claimName: scratch-disk-coco
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: scratch-disk-coco
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 100Gi
    
  2. Recherchez la variable d'environnement nommée DATA_BUCKET. Mettez à jour la value de cette variable vers le chemin d'accès à l'emplacement dans lequel vous souhaitez stocker l'ensemble de données COCO dans le bucket Cloud Storage. Par exemple : "gs:// my-maskrcnn-bucket / coco"

  3. Exécutez la commande suivante pour créer la tâche dans votre cluster :

    kubectl create -f download_and_preprocess_coco_k8s.yaml
    

Le démarrage des tâches peut prendre quelques minutes. Vous pouvez afficher l'état des tâches en cours d'exécution sur votre cluster à l'aide de la commande suivante :

kubectl get pods -w

Cette commande renvoie des informations sur toutes les tâches en cours d'exécution sur le cluster. Exemple :

NAME                                 READY     STATUS      RESTARTS   AGE
download-and-preprocess-coco-xmx9s   0/1       Pending     0          10s

L'indicateur -w donne l'ordre à la commande de surveiller les modifications apportées à l'état d'un pod. Après quelques minutes, l'état de la tâche doit passer à Running.

Si vous rencontrez des problèmes avec votre tâche, vous pouvez la supprimer avant de la recréer. Pour ce faire, exécutez la commande kubectl delete -f download_and_preprocess_coco_k8s.yaml, puis exécutez à nouveau la commande kubectl create.

Une fois le téléchargement et le prétraitement terminés, vous êtes prêt à exécuter le modèle.

Exécuter le modèle Mask RCNN

Vous pouvez désormais exécuter le modèle Mask RCNN à l'aide de Cloud TPU et de GKE.

  1. Dans votre environnement shell, créez un fichier nommé mask_rcnn_k8s.yaml, comme illustré ci-dessous. Vous pouvez également télécharger ce fichier depuis GitHub.

    # Train Mask-RCNN with Coco dataset using Cloud TPU and Google Kubernetes Engine.
    #
    # [Training Data]
    #   Download and preprocess the COCO dataset using https://github.com/tensorflow/tpu/blob/r1.13/tools/datasets/download_and_preprocess_coco_k8s.yaml
    #   if you don't already have the data.
    #
    # [Instructions]
    #   1. Follow the instructions on https://cloud.google.com/tpu/docs/kubernetes-engine-setup
    #      to create a Kubernetes Engine cluster.
    #   2. Change the environment variable MODEL_BUCKET in the Job spec to the
    #      Google Cloud Storage location where you want to store the output model.
    #   3. Run `kubectl create -f mask_rcnn_k8s.yaml`.
    
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: mask-rcnn-gke-tpu
    spec:
      template:
        metadata:
          annotations:
            # The Cloud TPUs that will be created for this Job must support
            # TensorFlow 1.13. This version MUST match the TensorFlow version that
            # your model is built on.
            tf-version.cloud-tpus.google.com: "1.13"
        spec:
          restartPolicy: Never
          containers:
          - name: mask-rcnn-gke-tpu
            # The official TensorFlow 1.13 TPU model image built from https://github.com/tensorflow/tpu/blob/r1.13/tools/docker/Dockerfile.
            image: gcr.io/tensorflow/tpu-models:r1.13
            command:
            - /bin/sh
            - -c
            - >
                DEBIAN_FRONTEND=noninteractive apt-get update &&
                DEBIAN_FRONTEND=noninteractive apt-get install -y python-dev python-tk libsm6 libxrender1 libxrender-dev libgtk2.0-dev libxext6 libglib2.0 &&
                pip install Cython matplotlib opencv-python-headless &&
                pip install 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI' &&
                python /tensorflow_tpu_models/models/experimental/mask_rcnn/mask_rcnn_main.py
                --model_dir=${MODEL_BUCKET}
                --iterations_per_loop=500
                --config=resnet_checkpoint=${RESNET_CHECKPOINT},resnet_depth=50,use_bfloat16=true,train_batch_size=64,eval_batch_size=8,training_file_pattern=${DATA_BUCKET}/train-*,validation_file_pattern=${DATA_BUCKET}/val-*,val_json_file=${DATA_BUCKET}/instances_val2017.json,total_steps=22500
            env:
              # The Google Cloud Storage location to store dataset.
            - name: DATA_BUCKET
              value: "gs://<my-data-bucket>"
            - name: MODEL_BUCKET
              value: "gs://<my-model-bucket>/mask_rcnn"
            - name: RESNET_CHECKPOINT
              value: "gs://cloud-tpu-artifacts/resnet/resnet-nhwc-2018-02-07/model.ckpt-112603"
    
              # Point PYTHONPATH to the top level models folder
            - name: PYTHONPATH
              value: "/tensorflow_tpu_models/models"
            resources:
              limits:
                # Request a single v3-8 Cloud TPU device to train the model.
                # A single v3-8 Cloud TPU device consists of 4 chips, each of which
                # has 2 cores, so there are 8 cores in total.
                cloud-tpus.google.com/v3: 8
    
  2. Recherchez la variable d'environnement nommée DATA_BUCKET. Mettez à jour la value de cette variable vers le chemin d'accès au fichier DATA_BUCKET que vous avez spécifié dans le script download_and_preprocess_coco_k8s.yaml.

  3. Recherchez la variable d'environnement nommée MODEL_BUCKET. Mettez à jour la value de cette variable vers le chemin d'accès à votre bucket Cloud Storage. Cet emplacement correspond à l'endroit où le script enregistre le résultat de l'entraînement. Si le MODEL_BUCKET spécifié n'existe pas, il est créé lors de l'exécution de la tâche.

  4. Exécutez la commande suivante pour créer la tâche dans votre cluster :

    kubectl create -f mask_rcnn_k8s.yaml
    

    Lorsque vous exécutez cette commande, le message de confirmation suivant apparaît :

    job "mask-rcnn-gke-tpu" created

Comme indiqué dans la section Traiter les données d'entraînement, le démarrage d'une tâche peut prendre quelques minutes. Affichez l'état des tâches en cours d'exécution sur votre cluster en exécutant la commande suivante :

kubectl get pods -w

Afficher l'état de l'entraînement

Vous pouvez suivre l'état de l'entraînement à l'aide de l'utilitaire de ligne de commande kubectl.

  1. Exécutez la commande suivante pour obtenir l'état de la tâche :

    kubectl get pods
    

    Pendant le processus d'entraînement, l'état du pod doit être RUNNING.

  2. Pour obtenir des informations supplémentaires sur le processus d'entraînement, exécutez la commande suivante :

    $ kubectl logs job name

    job name correspond au nom complet de la tâche, par exemple, mask-rcnn-gke-tpu-abcd.

    Vous pouvez également vérifier la sortie dans le tableau de bord des charges de travail GKE de Cloud Console.

    Notez que la première entrée peut mettre un certain temps à apparaître dans les journaux. Vous pouvez vous attendre à un résultat semblable au suivant :

    I0622 18:14:31.617954 140178400511808 tf_logging.py:116] Calling model_fn.
    I0622 18:14:40.449557 140178400511808 tf_logging.py:116] Create CheckpointSaverHook.
    I0622 18:14:40.697138 140178400511808 tf_logging.py:116] Done calling model_fn.
    I0622 18:14:44.004508 140178400511808 tf_logging.py:116] TPU job name worker
    I0622 18:14:45.254548 140178400511808 tf_logging.py:116] Graph was finalized.
    I0622 18:14:48.346483 140178400511808 tf_logging.py:116] Running local_init_op.
    I0622 18:14:48.506665 140178400511808 tf_logging.py:116] Done running local_init_op.
    I0622 18:14:49.135080 140178400511808 tf_logging.py:116] Init TPU system
    I0622 18:15:00.188153 140178400511808 tf_logging.py:116] Start infeed thread controller
    I0622 18:15:00.188635 140177578452736 tf_logging.py:116] Starting infeed thread controller.
    I0622 18:15:00.188838 140178400511808 tf_logging.py:116] Start outfeed thread controller
    I0622 18:15:00.189151 140177570060032 tf_logging.py:116] Starting outfeed thread controller.
    I0622 18:15:07.316534 140178400511808 tf_logging.py:116] Enqueue next (100) batch(es) of data to infeed.
    I0622 18:15:07.316904 140178400511808 tf_logging.py:116] Dequeue next (100) batch(es) of data from outfeed.
    I0622 18:16:13.881397 140178400511808 tf_logging.py:116] Saving checkpoints for 100 into gs://<bucket-name>/mask_rcnn/model.ckpt.
    I0622 18:16:21.147114 140178400511808 tf_logging.py:116] loss = 1.589756, step = 0
    I0622 18:16:21.148168 140178400511808 tf_logging.py:116] loss = 1.589756, step = 0
    I0622 18:16:21.150870 140178400511808 tf_logging.py:116] Enqueue next (100) batch(es) of data to infeed.
    I0622 18:16:21.151168 140178400511808 tf_logging.py:116] Dequeue next (100) batch(es) of data from outfeed.
    I0622 18:17:00.739207 140178400511808 tf_logging.py:116] Enqueue next (100) batch(es) of data to infeed.
    I0622 18:17:00.739809 140178400511808 tf_logging.py:116] Dequeue next (100) batch(es) of data from outfeed.
    I0622 18:17:36.598773 140178400511808 tf_logging.py:116] global_step/sec: 2.65061
    I0622 18:17:37.040504 140178400511808 tf_logging.py:116] examples/sec: 2698.56
    I0622 18:17:37.041333 140178400511808 tf_logging.py:116] loss = 2.63023, step = 200 (75.893 sec)
    
  3. Affichez le modèle entraîné à l'adresse gs://<bucket-name>/mask-rcnn/model.ckpt.

    gsutil ls -r gs://bucket-name/mask-rcnn/model.ckpt

Nettoyer

Une fois que vous n'avez plus besoin d'utiliser Cloud TPU sur GKE, nettoyez les ressources pour éviter que des frais supplémentaires ne soient imputés à votre compte de facturation Cloud.

Si vous n'avez pas défini le projet et la zone pour cette session, faites-le maintenant. Consultez les instructions plus haut dans ce guide. Suivez ensuite cette procédure de nettoyage :

  1. Exécutez la commande suivante pour supprimer le cluster GKE, tpu-models-cluster, en remplaçant project-name par le nom de votre projet Google Cloud :

    $ gcloud container clusters delete tpu-models-cluster --project=project-name
    
  2. Lorsque vous avez terminé l'examen des données, exécutez la commande gsutil pour supprimer le bucket Cloud Storage que vous avez créé dans ce tutoriel. Remplacez bucket-name par le nom de votre bucket Cloud Storage.

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

    Consultez la grille tarifaire de Cloud Storage pour connaître les limites en matière de stockage gratuit, ainsi que d'autres informations sur les tarifs.

Étapes suivantes