Como treinar o Mask R-CNN com o Cloud TPU e o GKE

Neste tutorial, mostramos como treinar o modelo Mask RCNN no Cloud TPU e no GKE.

Objetivos

  • Criar um intervalo do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
  • Criar um cluster do GKE para gerenciar os recursos do Cloud TPU.
  • Fazer o download de uma especificação de job do Kubernetes que descreva os recursos necessários para treinar o modelo Mask RCNN com o TensorFlow em um Cloud TPU.
  • Executar o job no cluster do GKE para começar a treinar o modelo.
  • Verificar os registros e a saída do modelo.

Custos

Neste tutorial, há componentes do Google Cloud Platform passíveis de cobrança, entre eles:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Use a calculadora de preços para gerar uma estimativa de custos baseada na projeção de uso. Novos usuários do GCP podem se qualificar para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Quando você usa a Cloud TPU com o GKE, são utilizados componentes faturáveis do Google Cloud Platform no seu projeto. Para fazer uma estimativa de custos, verifique os preços do Cloud TPU e os preços do GKE. Siga as instruções para limpar os recursos quando eles não forem mais necessários.

  5. Ative as APIs a seguir no Console do GCP:

Criar um intervalo do Cloud Storage

É preciso um intervalo do Cloud Storage para armazenar os dados usados para treinar o modelo e os resultados do treinamento. A ferramenta ctpu up usada neste tutorial configura permissões padrão para a conta de serviço do Cloud TPU. Caso queira permissões mais específicas, confira as permissões de nível de acesso.

  1. Acesse a página do Cloud Storage no Console do GCP.

    Acessar a página do Cloud Storage

  2. Crie um novo intervalo especificando as opções a seguir:

    • Um nome exclusivo à sua escolha
    • A classe de armazenamento padrão: Regional
    • O local: us-central1

Autorize o acesso da Cloud TPU ao intervalo do Cloud Storage

É necessário conceder à Cloud TPU acesso de leitura/gravação aos objetos do Cloud Storage. Para tanto, conceda à conta de serviço usada pela Cloud TPU o acesso necessário. Siga as instruções do guia para conceder acesso ao intervalo de armazenamento.

Criar um cluster no GKE

Siga as instruções abaixo para configurar o ambiente e criar um cluster do GKE compatível com o Cloud TPU usando a ferramenta de linha de comando gcloud.

  1. Abra uma janela do Cloud Shell.

    Abrir o Cloud Shell

  2. Especifique seu projeto do GCP:

    $ gcloud config set project YOUR-CLOUD-PROJECT
    

    em que YOUR-CLOUD-PROJECT é o nome do seu projeto do GCP.

  3. Especifique a zona em que você planeja usar um recurso da Cloud TPU. Neste exemplo, use a zona us-central1-b:

    $ gcloud config set compute/zone us-central1-b
    

    A Cloud TPU está disponível nas seguintes zonas:

    US

    Tipo de TPU (v2) Núcleos de TPU v2 Memória total de TPU Zonas disponíveis
    v2-8 8 64 GiB us-central1-a
    us-central1-b
    us-central1-c
    (us-central1-f apenas TFRC)
    v2-32 (Beta) 32 256 GiB us-central1-a
    v2-128 (Beta) 128 1 TiB us-central1-a
    v2-256 (Beta) 256 2 TiB us-central1-a
    v2-512 (Beta) 512 4 TiB us-central1-a
    Tipo de TPU (v3) Núcleos de TPU v3 Memória total de TPU Regiões disponíveis
    v3-8 8 128 GiB us-central1-a
    us-central1-b
    (us-central1-f apenas TFRC)

    Europa

    Tipo de TPU (v2) Núcleos de TPU v2 Memória total de TPU Zonas disponíveis
    v2-8 8 64 GiB europe-west4-a
    v2-32 (Beta) 32 256 GiB europe-west4-a
    v2-128 (Beta) 128 1 TiB europe-west4-a
    v2-256 (Beta) 256 2 TiB europe-west4-a
    v2-512 (Beta) 512 4 TiB europe-west4-a
    Tipo de TPU (v3) Núcleos de TPU v3 Memória total de TPU Regiões disponíveis
    v3-8 8 128 GiB europe-west4-a
    v3-32 (Beta) 32 512 GiB europe-west4-a
    v3-64 (Beta) 64 1 TiB europe-west4-a
    v3-128 (Beta) 128 2 TiB europe-west4-a
    v3-256 (Beta) 256 4 TiB europe-west4-a
    v3-512 (Beta) 512 8 TiB europe-west4-a
    v3-1024 (Beta) 1024 16 TiB europe-west4-a
    v3-2048 (Beta) 2048 32 TiB europe-west4-a

    Ásia-Pacífico

    Tipo de TPU (v2) Núcleos de TPU v2 Memória total de TPU Zonas disponíveis
    v2-8 8 64 GiB asia-east1-c
  4. Use o comando gcloud container clusters para criar um cluster no GKE compatível com o Cloud TPU. Observe que o cluster do GKE e os pools de nós dele precisam ser criados em uma zona em que o Cloud TPU esteja disponível, conforme descrito na seção acima sobre variáveis de ambiente. O comando a seguir cria um cluster chamado tpu-models-cluster:

    $ gcloud container clusters create tpu-models-cluster \
    --cluster-version=1.13 \
    --scopes=cloud-platform \
    --enable-ip-alias \
    --enable-tpu
    

    No comando acima:

    • --cluster-version=1.13 indica que o cluster usará a versão mais recente do Kubernetes 1.13. É necessário usar a versão 1.13.4-gke.5 ou posterior;
    • --scopes=cloud-platform garante que todos os nós no cluster tenham acesso ao intervalo do Cloud Storage no GCP, definido como YOUR-CLOUD-PROJECT acima. O cluster e o intervalo de armazenamento precisam estar no mesmo projeto. Por padrão, os pods herdam os escopos dos nós em que são implantados. Essa sinalização fornece a todos os pods em execução no cluster o escopo da cloud-platform. Para limitar o acesso por pod, veja como autenticar com contas de serviço no guia do GKE;
    • --enable-ip-alias indica que o cluster usa intervalos de IP de alias. Isso é necessário para usar a Cloud TPU no GKE;
    • --enable-tpu indica que o cluster precisa ser compatível com a Cloud TPU.

    Quando o comando terminar a execução, será exibida uma mensagem de confirmação semelhante a esta:

    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-2  1.13.6-gke.5   3          RUNNING
    

Processar os dados de treinamento

A próxima tarefa é criar um job. No Google Kubernetes Engine, um job é um objeto controlador que representa uma tarefa finita. O primeiro job que você precisa criar faz os downloads e processa o conjunto de dados COCO usado para treinar o modelo Mask RCNN.

  1. No ambiente shell, crie um arquivo chamado download_and_preprocess_coco_k8s.yaml conforme mostrado abaixo. Como alternativa, é possível fazer o download desse arquivo do 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
              - >
                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. Localize a variável de ambiente denominada DATA_BUCKET. Atualize o value dessa variável com o caminho para o intervalo do Cloud Storage.

  3. Execute o seguinte comando para criar o job no cluster:

    kubectl create -f download_and_preprocess_coco_k8s.yaml
    

Pode levar alguns minutos para os jobs serem iniciados. Visualize o status dos jobs em execução no cluster usando o seguinte comando:

kubectl get pods -w

Esse comando retorna informações sobre todos os jobs em execução no cluster. Exemplo:

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

A sinalização -w instrui o comando a observar quaisquer alterações no status de um pod. Depois de alguns minutos, o status do job será atualizado para Running.

Se você encontrar problemas com o job, exclua-o e tente novamente. Para fazer isso, execute o comando kubectl delete -f download_and_preprocess_coco_k8s.yaml antes de executar kubectl create novamente.

Executar o modelo Mask RCNN

Agora está tudo pronto para você executar o modelo Mask RCNN usando o Cloud TPU e o GKE.

  1. No ambiente shell, crie um arquivo chamado mask_rcnn_k8s.yaml conforme mostrado abaixo. Como alternativa, é possível fazer o download desse arquivo do 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/official/mask_rcnn/mask_rcnn_main.py
                --model_dir=${MODEL_BUCKET}
                --params_override=iterations_per_loop=500,resnet_checkpoint=${RESNET_CHECKPOINT},resnet_depth=50,precision=bfloat16,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. Localize a variável de ambiente denominada DATA_BUCKET. Atualize o value dessa variável com o caminho para o intervalo do Cloud Storage.

  3. Localize a variável de ambiente denominada MODEL_BUCKET. Atualize o value dessa variável com o caminho para o intervalo do Cloud Storage. É nesse local que o script salva a saída de treinamento.

  4. Execute o seguinte comando para criar o job no cluster:

    kubectl create -f mask_rcnn_k8s.yaml
    

    Ao executar esse comando, a seguinte mensagem de confirmação é exibida:

    job "mask-rcnn-gke-tpu" created

Conforme mencionado na seção Processar os dados de treinamento, pode levar alguns minutos para um job ser iniciado. Visualize o status dos jobs em execução no cluster usando o seguinte comando:

kubectl get pods -w

Visualizar o status do treinamento

Rastreie o status do treinamento usando o utilitário de linha de comando kubectl.

  1. Execute o seguinte comando para ver o status do job:

    kubectl get pods
    

    Durante o processo de treinamento, o status do pod precisa ser RUNNING.

  2. Para mais informações sobre o processo de treinamento, execute o seguinte comando:

    $ kubectl logs job name

    em que job name é o nome completo do job, por exemplo, mask-rcnn-gke-tpu-abcd.

    Também é possível verificar a resposta no painel de cargas de trabalho do GKE, no Console do GCP.

    Observe que leva algum tempo para que a primeira entrada apareça nos registros. Você verá algo como isto:

    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://<my-model-bucket>/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. Veja o modelo treinado em gs://<my-model-bucket>/mask-rcnn/model.ckpt.

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

Limpeza

Quando terminar de usar o Cloud TPU no GKE, limpe os recursos para evitar cobranças extras na conta do Google Cloud Platform.

Caso não tenha definido o projeto e a zona para esta sessão, faça isso agora. Consulte as instruções ensinadas anteriormente neste guia. Depois, siga este procedimento de limpeza:

  1. Para excluir o cluster do GKE, execute o comando tpu-models-cluster. Substitua YOUR-PROJECT pelo nome do projeto do GCP:

    $ gcloud container clusters delete tpu-models-cluster --project=YOUR-PROJECT
    
  2. Quando terminar de examinar os dados, use o comando gsutil para excluir o intervalo do Cloud Storage criado durante este tutorial. Substitua YOUR-BUCKET pelo nome do intervalo do Cloud Storage:

    $ gsutil rm -r gs://YOUR-BUCKET
    

    Consulte o guia de preços do Cloud Storage para se informar sobre os limites de armazenamento gratuito e outros preços.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…