Como executar o Deeplab-v3 no Cloud TPU

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

Nas instruções abaixo, presume-se que você conheça a execução de um modelo na Cloud TPU. Se você conhece a Cloud TPU há pouco tempo, consulte o guia de início rápido para ver os conceitos básicos.

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 machine learning, 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, há componentes faturáveis do Google Cloud, 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 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.

Abra uma janela do Cloud Shell.

Abra o Cloud Shell
Crie uma variável para o ID do seu projeto.
```
export PROJECT_ID=project-id
```
Configure a ferramenta de linha de comando gcloud para usar o projeto em que a Cloud TPU será criada.
```
gcloud config set project ${PROJECT_ID}
```
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.
Inicie uma VM do Compute Engine usando o comando ctpu up.
```
$ ctpu up --zone=us-central1-b \
 --machine-type=n1-standard-8 \
 --vm-only \
 --tf-version=1.15.3 \
 --name=deeplab-tutorial
```
Observação: se você tiver mais de um projeto, especifique o nome do projeto com a sinalização --project.
A configuração especificada aparecerá. Digite y para aprovar ou n para cancelar.
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, poderá conectar-se executando os seguintes comandos:
```
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

Crie variáveis de ambiente para o intervalo de armazenamento e o nome da 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

Preparar o conjunto de dados

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
```
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
```
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 --tpu-only \
  --tf-version=1.15.3 \
  --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}

Limpar

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

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.
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 --zone=us-central1-b \
  --name=deeplab-tutorial
```
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:
```
2018/04/28 16:16:23 WARNING: Setting zone to "us-central1-b"
No instances currently exist.
        Compute Engine VM:     --
        Cloud TPU:             --
```
Execute gsutil conforme mostrado. Substitua bucket-name pelo nome do bucket do Cloud Storage criado para este tutorial:
```
$ gsutil rm -r gs://bucket-name
```

A seguir

Neste tutorial, você treinou o modelo DeepLab-v3 usando um conjunto de dados de amostra. Os resultados deste treinamento (na maioria dos casos) não podem ser usados para inferência. Para usar um modelo para inferência, é possível treinar os dados em um conjunto de dados disponível publicamente ou no seu próprio conjunto de dados. Os modelos treinados nas Cloud TPUs 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 mais informações, 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. 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 mais informações 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 em 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.