Como treinar o EfficientNet no Cloud TPU

Os modelos EfficientNet são uma família de modelos de classificação de imagens com precisão de última geração, além de serem menores e mais rápidos do que outros modelos. Os EfficientNet-EdgeTpu são modelos personalizados para execução eficiente nos dispositivos Google EdgeTPU.

O modelo neste tutorial é baseado em EfficientNet: repensando o escalonamento de modelos para redes neurais convolucionais (em inglês). Os pesquisadores desenvolveram uma nova técnica para melhorar o desempenho do modelo: equilibrar cuidadosamente a profundidade, a largura e a resolução da rede, usando um coeficiente composto simples, mas altamente eficaz. A família de modelos, EfficientNets, de efficientnet-b0 a efficientnet-b7, pode alcançar precisão de classificação de imagem decente com um orçamento de computação diferente. efficientnet-b0, o modelo usado neste tutorial, corresponde ao menor modelo básico, enquanto efficientnet-b7 corresponde ao modelo mais potente, mas caro para computação. O tutorial demonstra o treinamento do modelo usando a TPUEstimator (em inglês).

Objetivos

Criar um intervalo do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
Prepare uma versão de teste do conjunto de dados do ImageNet, conhecido como conjunto de dados do fake_imagenet.
Executar o job de treinamento.
Verificar os resultados da saída.

Custos

Neste tutorial, há componentes faturáveis do Google Cloud Platform, 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. Os novos usuários do GCP podem estar qualificados para uma avaliação gratuita.

Antes de começar

Antes de começar o tutorial, verifique se o projeto do Google Cloud Platform foi configurado corretamente.

Faça login na sua Conta do Google.
Se você ainda não tiver uma, inscreva-se.
No Console do GCP, na página do seletor de projetos, selecione ou crie um projeto do GCP.

Observação: caso não queira manter os recursos criados usando este procedimento, crie um projeto em vez de selecionar um já existente. Depois de concluir essas etapas, é possível excluir o projeto, basta remover todos os recursos associados a ele.

Acesse a página do seletor de projetos
Verifique se o faturamento foi ativado no projeto do Google Cloud Platform. Saiba como confirmar que o faturamento está ativado para seu projeto.

Este tutorial inclui componentes faturáveis do Google Cloud Platform. Consulte a página de preços do Cloud TPU para fazer uma estimativa dos custos. Para evitar cobranças desnecessárias, não se esqueça de apagar os recursos criados ao terminar de usá-los.

Como configurar os recursos

Nesta seção, você verá como configurar os recursos de armazenamento, a VM e a Cloud TPU do Cloud Storage para tutoriais.

Abra uma janela do Cloud Shell.

Abrir o Cloud Shell
Crie uma variável para o nome do projeto.
```
export PROJECT_NAME=project_name
```
Configure a ferramenta de linha de comando gcloud para usar o projeto em que a Cloud TPU será criada.
```
gcloud config set project ${PROJECT_NAME}
```
Crie um intervalo do Cloud Storage usando o seguinte comando:
```
gsutil mb -p ${PROJECT_NAME} -c standard -l europe-west4 -b on gs://bucket-name/
```
Esse intervalo do Cloud Storage armazena 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, consulte as permissões de nível de acesso.

O local do intervalo precisa estar na mesma região da máquina virtual (VM) e do nó da TPU. As VMs e os nós da TPU estão localizados em zonas específicas, que são subdivisões dentro de uma região.
Inicie os recursos do Compute Engine e do Cloud TPU necessários usando o comando ctpu up.
```
ctpu up --zone=europe-west4-a \
  --vm-only \
  --disk-size-gb=300 \
  --machine-type=n1-standard-8 \
  --tf-version=1.14 \
  --name=efficientnet-tutorial
```
Observação: caso tenha mais de um projeto, especifique o nome do projeto.

Para mais informações sobre o utilitário do CTPU, consulte Referência do CTPU.
Quando solicitado, pressione y para criar os recursos do Cloud TPU.

Observação: a primeira vez que você executar o ctpu up em um projeto, ele levará cerca de 5 minutos para executar tarefas de inicialização, como propagação de chave SSH e ativação da API.

Quando o comando ctpu up terminar a execução, verifique se o prompt do shell foi alterado de username@project para username@tpuname. Essa alteração mostra que você fez login na VM do Compute Engine. Caso não esteja conectado à instância do Compute Engine, execute o seguinte comando:

gcloud compute ssh efficientnet-tutorial --zone=europe-west4-a

Daqui em diante, o prefixo (vm)$ significa que você precisa executar o comando na instância de VM do Compute Engine.

Prepare os dados

Configure as seguintes variáveis de ambiente, substituindo o nome do intervalo pelo nome do seu intervalo no Cloud Storage:

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export MODEL_BUCKET=${STORAGE_BUCKET}/efficientnet

O aplicativo de treinamento precisa que os dados de treinamento sejam acessíveis no Cloud Storage. Ele também usa o intervalo do Cloud Storage para armazenar pontos de verificação durante o treinamento.

Treine e avalie o modelo EfficientNet com o fake_imagenet

O ImageNet é um banco de dados de imagens. As imagens do banco de dados são organizadas hierarquicamente, com cada nó da hierarquia representado por centenas e milhares de imagens.

Neste tutorial, usamos uma versão de demonstração do conjunto de dados completo do ImageNet, conhecido como fake_imagenet. Essa versão de demonstração permite testar os tutoriais e reduzir os requisitos de tempo e armazenamento normalmente associados à execução de um modelo com o conjunto de dados completo do ImageNet.

O conjunto de dados do fake_imagenet está neste local no Cloud Storage:

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

O conjunto de dados do fake_imagenet é útil apenas para entender como usar uma Cloud TPU e validar o desempenho de ponta a ponta. Os números de acurácia e o modelo salvo não são importantes.

Para informações sobre como fazer o download e processar o conjunto de dados total do ImageNet, consulte Como fazer o download, o pré-processamento e o upload do conjunto de dados do ImageNet.

Inicie um recurso do Cloud TPU usando o utilitário ctpu.
```
(vm)$ ctpu up --tpu-only --name=efficientnet-tutorial
```
Adicione a pasta de nível superior /models ao caminho do Python com o comando
```
(vm)$ export PYTHONPATH="$PYTHONPATH:/usr/share/tpu/models"
```

Navegue até o diretório.

(vm)$ cd /usr/share/tpu/models/official/efficientnet/

Execute o script de treinamento.

(vm)$ python main.py \
  --tpu=efficientnet-tutorial \
  --data_dir=gs://cloud-tpu-test-datasets/fake_imagenet \
  --model_dir=${STORAGE_BUCKET}/efficientnet \
  --model_name='efficientnet-b0' \
  --skip_host_call=true \
  --train_batch_size=2048 \
  --train_steps=218948

Parâmetro	Descrição
`tpu`	Especifica o nome da Cloud TPU. Observe que `ctpu` passa esse nome para a VM do Compute Engine VM como uma variável de ambiente (`TPU_NAME`).
`data_dir`	Especifica o caminho do Cloud Storage para a entrada de treinamento. Neste exemplo, ele está definido com o conjunto de dados fake_imagenet.
`model_dir`	Especifica o diretório em que os checkpoints e os resumos são armazenados durante o treinamento do modelo. Se a pasta não existir, ela será criada pelo programa. Ao usar um Cloud TPU, o `model_dir` precisa ser um caminho do Cloud Storage (`gs://... `). É possível reutilizar uma pasta existente para carregar dados dos checkpoints atuais e armazenar outros checkpoints, contanto que os anteriores tenham sido criados usando uma TPU com o mesmo tamanho e versão do Tensorflow.

Este procedimento treina o modelo EfficientNet (variante efficientnet-b0) por 350 períodos e avalia cada número fixo de etapas. Usando as sinalizações especificadas, o modelo é treinado em cerca de 23 horas. Com dados reais do imagenet, as configurações precisam ter aproximadamente 76,5% de precisão no primeiro nível do conjunto de dados de validação do ImageNet. O melhor ponto de verificação do modelo e o resultado da avaliação correspondente estão dentro da pasta archive no diretório do modelo: ${STORAGE_BUCKET}/efficientnet/archive.

Como escalonar o modelo com os pods do Cloud TPU

Para resultados mais rápidos, escalone o modelo com os pods da Cloud TPU. O modelo totalmente compatível funciona com as seguintes frações de pod:

v2-32
v3-32

Ao trabalhar com pods da Cloud TPU, primeiro treine o modelo usando um pod e, em seguida, use um único dispositivo da Cloud TPU para avaliá-lo.

Como treinar com pods da Cloud TPU

Exclua o recurso do Cloud TPU criado para treinar o modelo em um único dispositivo.
```
(vm)$ ctpu delete --tpu-only --name=efficientnet-tutorial
```
Execute o comando ctpu up, usando o parâmetro tpu-size para especificar a fração de pod a ser usada. Por exemplo, o comando a seguir usa uma fração de pod v2-32.
```
(vm)$ ctpu up --tpu-only --tpu-size=v2-32 --name=efficientnet-pod
```
Atualize o diretório MODEL_BUCKET para armazenar os dados de treinamento.
```
(vm)$  export MODEL_BUCKET=${STORAGE_BUCKET}/efficientnet-pod
```

Treine o modelo, atualizando o parâmetro config_file para usar o arquivo de configuração que corresponde à fração de pod que você quer usar. Por exemplo, o script a seguir usa o arquivo de configuração v2-32.yaml.

(vm)$ python main.py \
  --tpu=efficientnet-pod \
  --data_dir=gs://cloud-tpu-test-datasets/fake_imagenet \
  --model_dir=${STORAGE_BUCKET}/efficientnet \
  --model_name='efficientnet-b3' \
  --skip_host_call=true \
  --mode=train \
  --train_steps=109474 \
  --train_batch_size=4096 \
  --iterations_per_loop=100

Parâmetro	Descrição
`tpu`	Especifica o nome da Cloud TPU. Observe que `ctpu` passa esse nome para a VM do Compute Engine VM como uma variável de ambiente (`TPU_NAME`).
`data_dir`	Especifica o caminho do Cloud Storage para a entrada de treinamento. Neste exemplo, ele está definido com o conjunto de dados fake_imagenet.
`model_dir`	Especifica o diretório em que os checkpoints e os resumos são armazenados durante o treinamento do modelo. Se a pasta não existir, ela será criada pelo programa. Ao usar um Cloud TPU, o `model_dir` precisa ser um caminho do Cloud Storage (`gs://...`). É possível reutilizar uma pasta existente para carregar dados dos checkpoints atuais e armazenar outros checkpoints, contanto que os anteriores tenham sido criados usando uma TPU com o mesmo tamanho e versão do Tensorflow.

O procedimento treina o modelo EfficientNet (variante efficientnet-b3) por 350 períodos. O modelo precisa ter 81,1% de acurácia no conjunto de desenvolvimento do ImageNet, o que deve terminar em cerca de 20 horas. O melhor ponto de verificação do modelo e o resultado da avaliação correspondente estão dentro da pasta archive no diretório do modelo: ${STORAGE_BUCKET}/efficientnet/archive.

Como avaliar o modelo

Nesta etapa, você usa a Cloud TPU para avaliar o modelo treinado acima usando os dados de validação do fake_imagenet.

Exclua o recurso do Cloud TPU criado para treinar o modelo.
```
(vm)$ ctpu delete --tpu-only --name=efficientnet-pod
```

Inicie um Cloud TPU v2-8.

(vm)$  ctpu up --tpu-only --name=efficientnet-pod-eval

Execute a avaliação do modelo. Desta vez, adicione a sinalização mode e defina-a como eval.

(vm)$  python main.py \
   --tpu=efficientnet-pod-eval \
   --data_dir=gs://cloud-tpu-test-datasets/fake_imagenet \
   --model_dir=${STORAGE_BUCKET}/efficientnet \
   --model_name='efficientnet-b3' \
   --skip_host_call=true \
   --mode=eval

Isso gera um resultado semelhante ao seguinte:

Eval results: {'loss': 7.532023, 'top_1_accuracy': 0.0010172526, 'global_step': 100, 'top_5_accuracy': 0.005065918}. Elapsed seconds: 88

Limpeza

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

Desconecte-se da instância do Compute Engine, caso ainda não tenha feito isso:
```
(vm)$ exit
```
Agora, o prompt será user@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 --name=efficientnet-tutorial --zone=europe-west4-a && \
ctpu delete --name=efficientnet-tutorial-pod --zone=europe-west4-a && \
ctpu delete --name=efficientnet-tutorial-pod-eval --zone=europe-west4-a
```
Importante: se você definir o nome dos recursos de TPU ao executar ctpu up, especifique esse nome com a sinalização --name quando executar ctpu delete para encerrar seus recursos de TPU.
Verificar se não há instâncias alocadas e evitar cobranças desnecessárias pelo uso da TPU.
```
ctpu status --zone=europe-west4-a
```
A exclusão de recursos 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 "europe-west4-a"
No instances currently exist.
        Compute Engine VM:     --
        Cloud TPU:             --
```
Execute gsutil conforme mostrado. Substitua YOUR-BUCKET-NAME pelo nome do intervalo do Cloud Storage criado para este tutorial:
```
$ gsutil rm -r gs://bucket-name
```

A seguir

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