Como treinar o RetinaNet no Cloud TPU

Neste documento, descrevemos uma implementação do modelo de detecção de objetos do RetinaNet. O código está disponível no GitHub.

Nas instruções abaixo, supomos que você já conheça a execução de um modelo no Cloud TPU. Caso contrário, veja as instruções para executar o modelo do ResNet no Cloud TPU.

Exoneração de responsabilidade

Este tutorial usa um conjunto de dados de terceiros. O Google não oferece declarações, proteções ou outras garantias sobre a validade ou quaisquer outros aspectos desse conjunto de dados.

Antes de começar

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

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

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Estas instruções incluem componentes faturáveis do Google Cloud Platform. Consulte a página de preços do Cloud TPU para estimar os custos. Depois, siga as instruções para limpar os recursos quando eles não forem mais necessários.

Criar um intervalo do Cloud Storage

Você precisa de um intervalo do Cloud Storage para armazenar os dados usados para treinar o modelo de aprendizado de máquina, bem como os resultados do treinamento.

  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
    • classe de armazenamento padrão: Regional
    • localização: us-central1

Abrir o Cloud Shell e usar a ferramenta ctpu

Neste guia, usamos o Cloud TPU Provisioning Utility (ctpu) como uma ferramenta simples para configurar e gerenciar o Cloud TPU. O guia executa o ctpu a partir de um Cloud Shell. Para encontrar opções de configuração mais avançadas, consulte a configuração personalizada.

A ferramenta ctpu vem pré-instalada no Cloud Shell. Siga estas etapas para verificar a configuração do ctpu:

  1. Abra uma janela do Cloud Shell.

    Abrir o Cloud Shell

  2. Para verificar a configuração do ctpu, digite o seguinte no Cloud Shell:

    $ ctpu print-config
    

    Você verá uma mensagem como esta:

    2018/04/29 05:23:03 WARNING: Setting zone to "us-central1-b"
    ctpu configuration:
            name: [your TPU's name]
            project: [your-project-name]
            zone: us-central1-b
    If you would like to change the configuration for a single command invocation, please use the command line flags.
    

  3. Confira os comandos do ctpu:

    $ ctpu

    Você verá um guia de uso, incluindo uma lista de subcomandos e sinalizações com uma breve descrição de cada.

Criar uma VM do Compute Engine e um Cloud TPU

Execute o comando a seguir para configurar uma máquina virtual (VM, na sigla em inglês) do Compute Engine e um Cloud TPU com serviços associados. Essa combinação de recursos e serviços é chamada de lote do Cloud TPU:

$ ctpu up

Com o comando ctpu up, você executa as tarefas a seguir:

  • Ativar os serviços do Cloud TPU e Compute Engine.
  • Criar uma VM do Compute Engine com a última versão estável do TensorFlow pré-instalada. A zona padrão é us-central1-b. Como referência, o Cloud TPU está disponível nas zonas a seguir:

    • Estados Unidos (EUA)
      • us-central1-b
      • us-central1-c
      • us-central1-f (apenas o programa TFRC)
    • Europa (EU)
      • europe-west4-a
    • Ásia-Pacífico (APAC)
      • asia-east1-c

  • Criar um Cloud TPU com a versão correspondente do TensorFlow e transmitir o nome do Cloud TPU para a VM do Compute Engine como uma variável de ambiente (TPU_NAME).

  • Garantir que o Cloud TPU tenha acesso aos recursos necessários no projeto do GCP. Isso é feito ao conceder papéis específicos do IAM à conta de serviço do Cloud TPU.
  • Executar várias outras verificações.
  • Fazer login na nova VM do Compute Engine.

É possível executar ctpu up quantas vezes quiser. Por exemplo, se você perder a conexão SSH com a VM do Compute Engine, basta executar ctpu up para restaurá-la.

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

Verificar a VM do Compute Engine

Quando a execução do comando ctpu up terminar, siga as seguintes etapas:

  1. Verifique se o prompt do shell mudou de username@project para username@username. Essa alteração mostra que você fez login na VM do Compute Engine.

  2. Execute o comando a seguir para verificar a instalação do TensorFlow:

    (vm)$ python -c "import tensorflow; print(tensorflow.VERSION)"
    

    Você verá uma mensagem de aviso seguida por uma linha que exibe o número da versão do TensorFlow. Por exemplo: 1.8.0.

Verificar o modelo do RetinaNet

Se a execução for realizada na VM pronta do Compute Engine, os arquivos do modelo do RetinaNet estarão no local a seguir:

(vm)$ ls /usr/share/tpu/models/official/retinanet/

Você também encontra a versão mais recente no GitHub:

$ git clone https://github.com/tensorflow/tpu/
$ ls tpu/models/official/retinanet

Preparar o conjunto de dados COCO

Configure a variável de ambiente a seguir, substituindo YOUR-BUCKET-NAME pelo nome do intervalo do Cloud Storage:

(vm)$ export STORAGE_BUCKET=gs://YOUR-BUCKET-NAME

Antes de poder fazer o treinamento, você precisa preparar os dados. O modelo do RetinaNet foi configurado para ser treinado no conjunto de dados COCO.

O script tpu/tools/datasets/download_and_preprocess_coco.sh converte o conjunto de dados COCO para um grupo de TFRecords necessário no aplicativo de treinamento.

Isso requer pelo menos 100 GB de espaço em disco no diretório de destino e leva quase 1 hora para ser concluído. Se não tiver essa quantidade de espaço na VM, será necessário anexar uma unidade de dados a ela.

Quando você tem um diretório de dados disponível, é possível executar o script de pré-processamento:

(vm)$ cd tpu/tools/datasets
(vm)$ bash download_and_preprocess_coco.sh ./data/dir/coco

Isso instala as bibliotecas necessárias e executa o script de pré-processamento. A saída são alguns arquivos *.tfrecord no diretório de dados. O script leva até uma hora para ser executado.

Você precisa copiar esses arquivos para o Cloud Storage para acessá-los no treinamento. Use gsutil para fazer a cópia. Também é necessário salvar os arquivos de anotação, que são usados para validar o desempenho do modelo:

(vm)$ gsutil -m cp ./data/dir/coco/*.tfrecord ${STORAGE_BUCKET}/coco
(vm)$ gsutil cp ./data/dir/coco/raw-data/annotations/*.json ${STORAGE_BUCKET}/coco

Instalar pacotes extras

O aplicativo de treinamento do RetinaNet requer vários pacotes extras. Instale-os agora:

(vm)$ sudo apt-get install -y python-tk
(vm)$ pip install Cython matplotlib
(vm)$ pip install 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI'

Executar o modelo

  1. Execute o aplicativo de treinamento em 100 etapas. Assim, você garante que tudo esteja funcionando e seja possível gravar pontos de verificação:

    (vm)$ RESNET_CHECKPOINT=gs://cloud-tpu-artifacts/resnet/resnet-nhwc-2018-02-07/model.ckpt-112603
    (vm)$ MODEL_DIR=${STORAGE_BUCKET}/retinanet-model

    (vm)$ python tpu/models/official/retinanet/retinanet_main.py \ --tpu=$TPU_NAME \ --train_batch_size=64 \ --training_file_pattern=${STORAGE_BUCKET}/coco/train-* \ --resnet_checkpoint=${RESNET_CHECKPOINT} \ --model_dir=${MODEL_DIR} \ --hparams=image_size=640 \ --num_examples_per_epoch=6400 \ --num_epochs=1

    • --tpu especifica o nome do Cloud TPU. O ctpu transmite esse nome para a VM do Compute Engine como uma variável de ambiente (TPU_NAME).
    • --resnet_checkpoint especifica um ponto de verificação pré-treinado. O RetinaNet requer um modelo de classificação de imagem pré-treinado como o ResNet para servir de rede de backbone. Nesse exemplo, usamos um ponto de verificação pré-treinado, criado com o modelo de demonstração do ResNet. Em vez disso, é possível treinar o próprio modelo do ResNet e especificar um ponto de verificação a partir do diretório do modelo do ResNet.

Avaliar o modelo durante o treinamento (opcional)

É possível avaliar o andamento do modelo em um conjunto de validação durante o treinamento. Como o código de avaliação do RetinaNet não funciona atualmente na VM do Cloud TPU, é necessário executá-lo em uma CPU ou GPU. Executar todas as imagens de validação é demorado. Por isso, recomendamos que você não interrompa o treinamento para a validação. Na verdade, é possível executá-la em paralelo em uma VM diferente. O executor de validação verifica o diretório do modelo em busca de novos pontos de verificação. Quando encontrados, novas métricas de avaliação são calculadas.

Primeiro, você precisa iniciar uma GPU para executar o script de avaliação. Isso requer a configuração extra descrita na seção a seguir.

VM de avaliação da GPU

Inicie a VM:

$ gcloud compute instances create eval-vm  \
 --machine-type=n1-highcpu-16  \
 --image-project=ubuntu-os-cloud  \
 --image-family=ubuntu-1604-lts  \
 --scopes=cloud-platform \
 --accelerator type=nvidia-tesla-p100 \
 --maintenance-policy TERMINATE \
 --restart-on-failure

Depois de um minuto, você poderá se conectar:

$ gcloud compute ssh eval-vm

Para que o TensorFlow use sua imagem, você precisa configurar o CUDA, que é uma plataforma de computação paralela da NVIDIA. Os comandos a seguir são executados na VM de avaliação. Eles instalam o CUDA e o TensorFlow em uma VM da GPU. Após concluir a instalação, reinicie a VM.

(vm)$ cat > /tmp/setup.sh <(vm)$ wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/cuda-repo-ubuntu1604_9.0.176-1_amd64.deb

(vm)$ dpkg -i ./cuda-repo-ubuntu1604_9.0.176-1_amd64.deb
(vm)$ apt-key adv --fetch-keys http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/7fa2af80.pub
(vm)$ apt-get update
(vm)$ apt-get install -y cuda-9-0
(vm)$ bash -c 'echo "deb http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64 /" > /etc/apt/sources.list.d/nvidia-ml.list'
(vm)$ apt-get update
(vm)$ apt-get install -y --no-install-recommends libcudnn7=7.0.5.15-1+cuda9.0
(vm)$ apt install -y python-pip python-tk
(vm)$ pip install tensorflow-gpu==1.8
(vm)$ HERE

(vm)$ sudo bash /tmp/setup.sh

Também é possível usar uma VM da CPU para a avaliação. Esse processo requer menos configurações, mas é muito mais lento:

$ gcloud compute instances create \
 retinanet-eval-vm \
  --machine-type=n1-highcpu-64 \
  --image-project=ml-images \
  --image-family=tf-1-8 \
  --scopes=cloud-platform

Agora você pode se conectar à VM de avaliação e iniciar esse ciclo.

Como instalar pacotes e verificar o modelo do RetinaNet

Em qualquer tipo de VM, como mencionado, você precisa instalar os pacotes a seguir:

(vm)$ sudo apt-get install -y python-tk
(vm)$ pip install Cython matplotlib
(vm)$ pip install 'git+https://github.com/pdollar/coco.git#egg=pycocotools&subdirectory=PythonAPI'

É necessário coletar o código do modelo do RetinaNet para a avaliação:

(vm)$ git clone https://github.com/tensorflow/tpu

Como executar a avaliação

Agora é possível executar o script de avaliação. Primeiro, faça uma avaliação rápida para testar se você pode ler o diretório do modelo e os arquivos de validação.

Configure uma variável que contém o intervalo do Cloud Storage e copie o arquivo de anotação criado durante o pré-processamento. Em seguida, execute o modelo:

(vm)$ export STORAGE_BUCKET=gs://YOUR-BUCKET-NAME
(vm)$ gsutil cp ${STORAGE_BUCKET}/coco/instances_val2017.json .

(vm)$ python tpu/models/official/retinanet/retinanet_main.py  \
 --use_tpu=False \
 --validation_file_pattern=${STORAGE_BUCKET}/coco/val-* \
 --val_json_file=./instances_val2017.json \
 --model_dir=${STORAGE_BUCKET}/retinanet-model/ \
 --hparams=image_size=640 \
 --mode=eval \
 --num_epochs=1 \
 --num_examples_per_epoch=100 \
 --eval_steps=10

Os parâmetros num_epochs=1 e eval_steps=10 são usados para garantir que o script seja concluído com rapidez. Aumente esses parâmetros para que a execução aconteça em todo o conjunto de dados de avaliação:

(vm)$ python tpu/models/official/retinanet/retinanet_main.py  \
 --use_tpu=False \
 --validation_file_pattern=${STORAGE_BUCKET}/coco/val-* \
 --val_json_file=./instances_val2017.json \
 --model_dir=${STORAGE_BUCKET}/retinanet-model/ \
 --hparams=image_size=640 \
 --num_epochs=15 \
 --mode=eval \
 --eval_steps=5000

A execução leva cerca de 10 minutos nas 5.000 etapas de avaliação. Depois de terminar, o avaliador continua aguardando novos pontos de verificação do aplicativo de treinamento por até 1 hora. Você não precisa esperar que a avaliação seja concluída: é possível iniciar agora um treinamento completo.

Executar novamente o aplicativo de treinamento

Voltando para a VM original, agora você está pronto para executar o modelo nos dados COCO pré-processados. O treinamento completo leva quase 6 horas.

(vm)$ python tpu/models/official/retinanet/retinanet_main.py \
 --tpu=$TPU_NAME \
 --train_batch_size=64 \
 --training_file_pattern=${STORAGE_BUCKET}/coco/train-* \
 --resnet_checkpoint=${RESNET_CHECKPOINT} \
 --model_dir=${STORAGE_BUCKET}/retinanet-model/ \
 --hparams=image_size=640 \
 --num_epochs=15

Verificar o status do treinamento

Use o TensorBoard para ver o progresso do treinamento.

Quando você configura uma VM de avaliação, ela lê continuamente novos pontos de verificação e coloca as saídas dos eventos de avaliação no diretório model_dir. Veja o status atual do treinamento e avaliação no TensorBoard:

(vm)$ tensorboard --logdir=${MODEL_DIR} &

Ao executar ctpu up, a ferramenta configura automaticamente o encaminhamento de portas no ambiente do Cloud Shell para disponibilizar o TensorBoard.

Clique no botão Visualização da Web no Cloud Shell e abra a porta 8080.

Limpar

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

    (vm)$ exit
    

    O prompt agora será user@projectname, mostrando que você está no Cloud Shell.

  2. No Cloud Shell, execute o comando a seguir para excluir a VM do Compute Engine e o Cloud TPU:

    $ ctpu delete
    

  3. Execute ctpu status para garantir que você não tenha instâncias alocadas. A exclusão pode levar até dois 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.
            GCE VM:     --
            Cloud TPU:  --
    

  4. Quando você não precisar mais do intervalo do Cloud Storage criado neste tutorial, use o comando gsutil para excluí-lo. Substitua YOUR-BUCKET-NAME pelo nome do intervalo no Cloud Storage:

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

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

Se tiver usado quaisquer outras VMs do Compute Engine na etapa de avaliação, não esqueça de excluí-las também.

$ gcloud compute instances delete YOUR-INSTANCE-NAME

Próximas etapas

  • Nas instruções deste tutorial, supomos que você queira fazer o treinamento em uma imagem de 640 x 640 pixels. Altere o hiperparâmetro image_size para treinar em uma imagem menor. O resultado é um modelo mais rápido, mas menos preciso.

  • Se preferir, você pode fazer o pré-treinamento de um modelo do ResNet no próprio conjunto de dados e usá-lo como base para o modelo do RetinaNet. Com mais algumas ações, também é possível usar uma rede de backbone alternativa em vez do ResNet. Por fim, se tiver interesse em implementar os próprios modelos de detecção de objetos, essa rede é uma ótima base para novas experimentações.

  • Saiba mais sobre o ctpu, incluindo como instalá-lo em uma máquina local.

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

Enviar comentários sobre…