Como executar o Deeplab-v3 no Cloud TPU

Este tutorial mostra como treinar o modelo Deeplab-v3 no Cloud TPU.

Nas instruções abaixo, supomos que você já conheça a execução de um modelo no Cloud TPU. Se você não estiver familiarizado com o Cloud TPU, consulte o Guia de início rápido para uma introdução básica.

Se você planeja treinar em uma fração do pod da TPU, veja como realizar o treinamento em pods de TPU para entender as alterações de parâmetros necessárias para frações de pod.

Este modelo é um modelo de segmentação semântica de imagem. Os modelos de segmentação semântica de imagem concentram-se em identificar e localizar vários objetos em uma única imagem. Esse tipo de modelo é frequentemente usado em aplicativos de aprendizado de máquina, como condução autônoma, processamento de imagens geoespaciais e imagens médicas.

Neste tutorial, você executará um modelo de treinamento contra o conjunto de dados PASCAL VOC 2012. Para mais informações sobre esse conjunto de dados, consulte a página inicial de classes de objetos visuais do PASCAL.

Objetivos

• Criar um bucket do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
• Instale os pacotes necessários.
• Fazer o download e converter o conjunto de dados PASCAL VOC 2012.
• Treine o modelo Deeplab.
• Avalie o modelo Deeplab.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

• Compute Engine
• Cloud TPU
• Cloud Storage

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

Nesta seção, você verá como configurar o bucket do Cloud Storage e a VM do Compute Engine.

Importante: configure a VM do Compute Engine, o nó da Cloud TPU e o bucket do Cloud Storage na mesma região/zona para reduzir a latência e os custos da rede.

1. Abra uma janela do Cloud Shell.

   Abra o Cloud Shell

2. Crie uma variável para o ID do seu projeto.

   export PROJECT_ID=project-id
   

3. Configure a CLI do Google Cloud para usar o projeto em que você quer criar a Cloud TPU.

   gcloud config set project ${PROJECT_ID}
   

   Na primeira vez que você executar esse comando em uma nova VM do Cloud Shell, será exibida uma página Authorize Cloud Shell. Clique em Authorize na parte inferior da página para permitir que gcloud faça chamadas de API do GCP com suas credenciais.

4. Crie uma conta de serviço para o projeto da Cloud TPU.

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

   O comando retorna uma conta de serviço do Cloud TPU com o formato a seguir:

   [e-mail]
   

5. Crie um bucket do Cloud Storage usando o seguinte comando:

   Observação: no comando a seguir, substitua bucket-name pelo nome que você quer atribuir ao bucket.

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

   Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento.

   Para que a Cloud TPU leia e grave no bucket de armazenamento, a conta de serviço do seu projeto precisa de permissões de leitura/gravação ou administrador. Consulte a seção sobre buckets de armazenamento para ver e definir essas permissões.

6. Inicie uma VM do Compute Engine usando o comando ctpu up.

   Observação: neste tutorial, usamos o TensorFlow 1.15.5, que é baseado na imagem do Debian 10 e o padrão do Python 3.6 é usado. As versões anteriores do TensorFlow 1.15.x eram baseadas no Debian 9 e são padrão para o Python 3.5.

   $ ctpu up --project=${PROJECT_ID} \
    --zone=us-central1-b \
    --machine-type=n1-standard-8 \
    --vm-only \
    --tf-version=1.15.5 \
    --name=deeplab-tutorial
   

   Descrições de sinalizações de comando

   project

   O ID do projeto do GCP

   zone

   A zona em que você planeja criar a Cloud TPU.

   machine-type

   O tipo de máquina da VM do Compute Engine a ser criada.

   vm-only

   Crie somente uma VM. Por padrão, o comando ctpu up cria uma VM e uma Cloud TPU.

   tf-version

   A versão ctpu do Tensorflow é instalada na VM.

   name

   O nome do Cloud TPU a ser criado.

7. A configuração especificada aparecerá. Digite y para aprovar ou n para cancelar.

8. Quando o comando ctpu up terminar a execução, verifique se o prompt do shell foi alterado de username@projectname para username@vm-name. Essa alteração mostra que você fez login na VM do Compute Engine.

   Observação: se você não estiver conectado à instância do Compute Engine, execute os comandos a seguir:

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

Ao seguir essas instruções, execute cada comando iniciado por (vm)$ na janela de sessão da VM.

Instale pacotes adicionais

Para este modelo, é necessário instalar os seguintes pacotes adicionais na instância do 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. Crie variáveis de ambiente para o intervalo de armazenamento e o nome da TPU.

   Observação: nos comandos a seguir, substitua bucket-name pelo nome do seu bucket.

   (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
   

Preparar o conjunto de dados

1. Faça o download e converta o conjunto de dados PASCAL VOC 2012

   Este modelo usa o conjunto de dados PASCAL VOC 2012 para treinamento e avaliação. Execute o script a seguir para fazer o download do conjunto de dados e convertê-lo no formato TFRecord do TensorFlow:

    (vm)$ bash /usr/share/models/research/deeplab/datasets/download_and_convert_voc2012.sh
   

2. Faça o download do checkpoint pré-treinado

   Nesta etapa, faça o download do ponto de verificação pré-roteado modificado do resnet 101. Para começar, faça o download do checkpoint:

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

   Em seguida, extraia o conteúdo do arquivo tar:

    (vm)$ tar -vxf resnet_v1_101_2018_05_04.tar.gz
   

3. Carregue dados no seu bucket do Cloud Storage

   Nesse momento, é possível fazer o upload dos dados para o bucket do Cloud Storage criado anteriormente:

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

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

Criar um recurso do Cloud TPU

Execute o comando a seguir para criar o Cloud TPU.

  (vm)$ ctpu up --project=${PROJECT_ID} \
  --tpu-only \
  --tf-version=1.15.5 \
  --tpu-size=v3-8 \
  --name=deeplab-tutorial

Treine o modelo

Execute o script de treinamento para 2.000 etapas de treinamento. Isso levará aproximadamente 20 minutos. Para executar a conversão, remova a sinalização --train_steps=2000 da linha de comando do script de treinamento. A execução da conversão leva cerca de 10 horas.

(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}

Como avaliar o modelo em um dispositivo do Cloud TPU.

Quando o treinamento terminar, será possível avaliar o modelo. Para fazer isso, altere a sinalização --mode de train para 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} \
--eval_timeout=200

Observação: no comando de avaliação acima, eval_timeout está definido como 200, o que encerra a avaliação após 200 segundos. Isso é necessário porque o loop de avaliação foi projetado para ser executado em paralelo com o treinamento, em que ele continua verificando se há novos checkpoints para a avaliação. O script poderá parecer travado se o loop de avaliação estiver aguardando a criação de um checkpoint. Por padrão, o loop de avaliação é interrompido após 50.000 etapas de treinamento.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

1. Encerre a conexão com a VM do Compute Engine:

   (vm)$ exit
   

   Agora, o prompt precisa ser username@projectname, mostrando que você está no Cloud Shell.

2. No Cloud Shell, execute ctpu delete com a sinalização --zone usada ao configurar a Cloud TPU para excluir a VM do Compute Engine e a Cloud TPU:

   $ ctpu delete --project=${PROJECT_ID} \
     --zone=us-central1-b \
     --name=deeplab-tutorial
   

3. Execute ctpu status para garantir que não haja instâncias alocadas e evitar cobranças desnecessárias no uso da TPU. A exclusão pode levar vários minutos. Uma resposta como esta indica que não há mais instâncias alocadas:

   $ ctpu status --project=${PROJECT_ID} \
     --name=deeplab-tutorial \
     --zone=us-central1-b
   

   2018/04/28 16:16:23 WARNING: Setting zone to "us-central1-b"
   No instances currently exist.
           Compute Engine VM:     --
           Cloud TPU:             --
   

4. Execute gsutil conforme mostrado. Substitua bucket-name pelo nome do bucket do Cloud Storage criado para este tutorial:

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

Observação: para saber mais sobre limites de armazenamento gratuito e outras informações sobre preços, consulte o guia de preços do Cloud Storage.

A seguir

Geralmente, os tutoriais do Cloud TPU do TensorFlow treinam o modelo usando um conjunto de dados de amostra. Os resultados deste treinamento não podem ser usados para inferência. Para usar um modelo para inferência, treine os dados em um conjunto de dados disponível publicamente ou em seu próprio conjunto de dados. Os modelos do TensorFlow treinados em Cloud TPUs geralmente exigem que os conjuntos de dados estejam no formato TFRecord.

Use a amostra da ferramenta de conversão de conjunto de dados para converter um conjunto de dados de classificação de imagem no formato TFRecord. Se você não estiver usando um modelo de classificação de imagem, converta manualmente o conjunto de dados para o TFRecord. Para saber mais, consulte TFRecord e tf.Example.

Ajuste de hiperparâmetros

Para melhorar o desempenho do modelo com o conjunto de dados, é possível ajustar os hiperparâmetros do modelo. Encontre informações sobre hiperparâmetros comuns a todos os modelos compatíveis com a TPU no GitHub. As informações sobre hiperparâmetros específicos do modelo podem ser encontradas no código-fonte de cada modelo. Para saber mais sobre o ajuste de hiperparâmetros, consulte Visão geral do ajuste de hiperparâmetros, Como usar o serviço de ajuste de hiperparâmetros e Ajustar hiperparâmetros.

Inferência

Depois de treinar o modelo, é possível usá-lo para inferência (também chamada de previsão). O AI Platform é uma solução baseada na nuvem para desenvolver, treinar e implantar modelos de machine learning. Depois que um modelo é implantado, use o serviço do AI Platform Prediction.

• Saiba mais sobre ctpu, incluindo como instalá-lo em uma máquina local.
• Teste mais amostras de TPU.
• Conheça as ferramentas de TPU no TensorBoard.