Como treinar o ShapeMask na Cloud TPU

Neste documento, você verá como executar o modelo ShapeMask usando a Cloud TPU com o conjunto de dados COCO.

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.

Objetivos

  • Criar um intervalo do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
  • Preparar o conjunto de dados COCO.
  • Configurar uma VM do Compute Engine e um nó da Cloud TPU para treinamento e avaliação.
  • Executar treinamento e avaliação em uma única Cloud TPU ou em um pod da Cloud TPU.

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

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

  1. Abra uma janela do Cloud Shell.

    Abrir o Cloud Shell

  2. Crie uma variável para o nome do projeto.

    export PROJECT_NAME=your-project_name
    
  3. Configure a ferramenta de linha de comando da gcloud para usar o projeto em que a Cloud TPU será criada.

    gcloud config set project ${PROJECT_NAME}
    
  4. Crie um intervalo do Cloud Storage usando o seguinte comando:

    gsutil mb -p ${PROJECT_NAME} -c standard -l europe-west4 -b on gs://your-bucket-name
    

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

  5. Inicie uma instância de VM do Compute Engine.

    $ gcloud compute instances create shapemask-tutorial \
     --zone europe-west4-a \
     --image-project=ml-images \
     --image=debian-9-tf-1-14-v20190910 \
     --network default \
     --machine-type n1-standard-16 \
     --scopes cloud-platform \
     --boot-disk-size=500GB
    
  6. Conecte-se à instância de VM.

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

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

Preparar o conjunto de dados COCO

  1. Crie uma variável para armazenar o local do intervalo do Cloud Storage.

    (vm)$ export STORAGE_BUCKET=your-bucket-name
    
  2. Clone o repositório tpu.

    (vm)$ git clone -b shapemask https://github.com/tensorflow/tpu/
    
  3. Instale os pacotes necessários para pré-processar os dados.

    (vm)$ sudo apt-get install -y python-tk && \
      pip install --user Cython matplotlib opencv-python-headless pyyaml Pillow && \
      pip install --user 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI'
    
  4. Crie um diretório para armazenar os dados COCO e navegue até ele.

    (vm)$ mkdir ~/data && \
    mkdir ~/data/coco && \
    cd ~/tpu/tools/datasets
    
  5. Execute o script download_and_preprocess_coco.sh para converter o conjunto de dados COCO em um conjunto de TFRecords (*.tfrecord) esperado pelo aplicativo de treinamento.

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

    Isso instala as bibliotecas necessárias e executa o script de pré-processamento. Ele gera uma série de arquivos *.tfrecord no diretório de dados locais. O script de download e conversão do COCO leva aproximadamente 1 hora para ser concluído.

  6. Depois de converter os dados para TFRecords, use o comando gsutil para copiá-los do armazenamento local para o intervalo do Cloud Storage. Também é preciso copiar os arquivos de anotação. Eles ajudam a validar o desempenho do modelo:

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

Como treinar os modelos

  1. Inicie um recurso da Cloud TPU.

    $ gcloud beta compute tpus create shapemask-tutorial \
     --range=10.4.27.0 \
     --accelerator-type v3-32 \
     --version nightly \
     --network=default \
     --zone=europe-west4-a
    
  2. Configure as seguintes variáveis de ambiente:

    (vm)$ TPU_NAME=shapemask-tutorial; \
    MODEL_DIR=gs://${STORAGE_BUCKET}/shapemask_exp/; \
    RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/shapemask/retinanet/resnet101-checkpoint-2018-02-24; \
    TRAIN_FILE_PATTERN=gs://${STORAGE_BUCKET}/coco/train-*; \
    EVAL_FILE_PATTERN=gs://${STORAGE_BUCKET}/coco/val-*; \
    VAL_JSON_FILE=gs://${STORAGE_BUCKET}/coco/instances_val2017.json; \
    SHAPE_PRIOR_PATH=gs://cloud-tpu-checkpoints/shapemask/kmeans_class_priors_91x20x32x32.npy; \
    PYTHONPATH="$PYTHONPATH:~/tpu/models"
    
  3. Execute o script de treinamento:

    (vm)$ python ~/tpu/models/official/detection/main.py \
    --model shapemask \
    --use_tpu=True \
    --tpu=${TPU_NAME} \
    --num_cores=32 \
    --model_dir="${MODEL_DIR}" \
    --mode="train" \
    --eval_after_training=True \
    --params_override="{train: {iterations_per_loop: 1000, train_batch_size: 64, total_steps: 45000, learning_rate: {total_steps: 45000, warmup_learning_rate: 0.0067, warmup_steps: 500, init_learning_rate: 0.08, learning_rate_levels: [0.008, 0.0008], learning_rate_steps: [30000, 40000]}, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet101/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, resnet: {resnet_depth: 101}, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: 5000 }, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}}, shapemask_parser: {output_size: [1024, 1024]}, }"
    

Limpeza

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

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

  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 --zone=europe-west4-a
    
  3. Execute o seguinte comando para verificar se a VM do Compute Engine e a Cloud TPU foram encerradas:

    $ ctpu status --zone=europe-west4-a
    

    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 "europe-west4-a"
    No instances currently exist.
            Compute Engine VM:     --
            Cloud TPU:             --
    
  4. Execute gsutil, conforme mostrado, substituindo your-bucket-name pelo nome do intervalo do Cloud Storage criado para este tutorial:

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

A seguir

Treinar com diferentes tamanhos de imagem

Para explorar, use uma rede de backbone maior. Por exemplo, ResNet-101 em vez de ResNet-50. Uma imagem maior de entrada e um backbone mais potente produzirão um modelo mais lento, porém, mais preciso.

Usar uma base diferente

Se preferir, faça o pré-treinamento de um modelo do ResNet no seu próprio conjunto de dados e use-o como base para o modelo do ShapeMask. Com um pouco mais de trabalho, também é possível alternar uma outra rede de backbone em vez do ResNet. Por fim, caso tenha interesse em implementar modelos próprios de detecção de objetos, essa rede pode ser uma boa base para fazer mais experimentos.

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

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.