Como treinar o AmoebaNet-D no Cloud TPU

O modelo do AmoebaNet-D é uma das arquiteturas de classificadores de imagem descobertas com o uso do AutoML evolucionário. O modelo é baseado nos resultados do artigo da AmoebaNet: Real, E., Aggarwal, A., Huang, Y. e Le, Q.V., 2018, Regularized Evolution for Image Classifier Architecture Search, impressão preliminar do arXiv: 1802.01548.

Esse modelo usa o TPUEstimator, que é uma API detalhada do TensorFlow recomendada para criar e executar um modelo de aprendizado de máquina em um Cloud TPU.

A API simplifica o processo de desenvolvimento do modelo ao ocultar a maior parte da implementação de nível baixo. Isso facilita a alternância entre o TPU e outras plataformas como GPU ou CPU.

Objetivos

  • Criar um bucket do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
  • Preparar 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, 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

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

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Este tutorial usa componentes faturáveis do Google Cloud. Consulte a página de preços da 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.

Configurar os recursos

Nesta seção, fornecemos informações sobre como configurar recursos do bucket do Cloud Storage, da VM e da Cloud TPU para tutoriais.

  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 ferramenta de linha de comando gcloud para usar o projeto em que a Cloud TPU será criada.

    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:

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    

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

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

    Esse bucket 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 da Cloud TPU. Caso queira permissões mais específicas, consulte as permissões de nível de acesso.

    O local do bucket 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.

  6. Inicie os recursos do Compute Engine e da Cloud TPU necessários usando o comando ctpu up.

    ctpu up --project=${PROJECT_ID} \
     --zone=europe-west4-a \
     --vm-only \
     --disk-size-gb=300 \
     --machine-type=n1-standard-8 \
     --tf-version=1.15.4 \
     --name=amoebanet-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.
    vm-only
    Cria a VM sem criar uma Cloud TPU. Por padrão, o comando ctpu up cria uma VM e uma Cloud TPU.
    disk-size-gb
    O tamanho do disco rígido em GB da VM criada pelo comando ctpu up .
    machine-type
    O tipo de máquina da VM do Compute Engine a ser criado.
    tf-version
    A versão do ctpu do Tensorflow é instalada na VM.
    name
    O nome da Cloud TPU a ser criada.

    Para mais informações sobre o utilitário do CTPU, consulte Referência do CTPU.

  7. Quando solicitado, pressione y para criar os recursos da Cloud TPU.

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. Caso não esteja conectado à instância do Compute Engine, execute o seguinte comando:

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

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

Prepare os dados

O aplicativo de treinamento precisa que os dados de treinamento sejam acessíveis no Cloud Storage. Ele também usa o bucket do Cloud Storage para armazenar checkpoints durante o treinamento.

Treinar e avaliar o modelo AmoebaNet-D com 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 é útil apenas para entender como usar um 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 (em inglês).

Nas etapas a seguir, o prefixo (vm)$ significa que você precisa executar o comando na VM do Compute Engine.

  1. Inicie um recurso da Cloud TPU usando o utilitário ctpu.

    (vm)$ ctpu up --project=${PROJECT_ID} \
    --tpu-only \
     --name=amoebanet-tutorial \
     --tf-version=1.15.4
    
  2. Configure as seguintes variáveis de ambiente, substituindo bucket-name pelo nome do bucket do Cloud Storage:

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/amoebanet
    (vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/tpu/models"
    
    (vm)$ export TPU_NAME=amoebanet-tutorial
    
  3. Navegue até o diretório.

    (vm)$ cd /usr/share/tpu/models/official/amoeba_net/
    
  4. Execute o script de treinamento.

    (vm)$ python3 amoeba_net.py \
       --tpu=${TPU_NAME} \
       --data_dir=${DATA_DIR} \
       --model_dir=${MODEL_DIR} \
       --num_epochs=1
    
    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 um TPU com o mesmo tamanho e versão do TensorFlow.

Para um único dispositivo Cloud TPU, este procedimento treina o modelo AmoebaNet-D para 1 período e avalia cada número fixo de etapas. Usando as sinalizações especificadas, o modelo deve treinar em aproximadamente 30 minutos em uma Cloud TPU v3-8. O treinamento para a conversão leva cerca de 90 períodos e aproximadamente 10 horas.

Como o treinamento e a avaliação foram feitos no fake_imagenet, os resultados não refletem a saída real que apareceria se o treinamento e a avaliação fossem realizados em um conjunto de dados real.

A partir daqui, é possível concluir este tutorial e limpar os recursos do GCP ou explorar a execução do modelo em pods da Cloud TPU.

Como escalonar o modelo com os pods da Cloud TPU

Para resultados mais rápidos, escalone o modelo com os pods do Cloud TPU. O modelo AmoebaNet 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

  1. Exclua o recurso da Cloud TPU criado para treinar o modelo em um único dispositivo.

    (vm)$ ctpu delete --project=${PROJECT_ID} \
     --tpu-only \
     --name=amoebanet-tutorial \
     --zone=europe-west4-a
  2. 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 --project=${PROJECT_ID} \
      --tpu-only \
      --tf-version=1.15.4 \
      --tpu-size=v2-32 \
      --name=amoebanet-tutorial-pod \
      --zone=europe-west4-a
    
  3. Atualize o diretório MODEL_BUCKET para armazenar os dados de treinamento do pod.

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/amoebanet-tutorial-pod
    (vm)$ export TPU_NAME=amoebanet-tutorial-pod
    
  4. Treine o modelo na VM do Compute Engine com as seguintes sinalizações:

    (vm)$ python3 amoeba_net.py \
       --tpu=${TPU_NAME} \
       --data_dir=${DATA_DIR} \
       --model_dir=${MODEL_DIR} \
       --num_cells=6 \
       --image_size=224 \
       --num_epochs=1 \
       --train_batch_size=4096 \
       --eval_batch_size=1000 \
       --lr=10.24 \
       --lr_decay_value=0.88 \
       --num_shards=32 \
       --lr_warmup_epochs=0.35 \
       --mode=train \
       --iterations_per_loop=1000
    
    Parâmetro Descrição
    tpu Especifica o nome da Cloud TPU. Observe que ctpu passa esse nome para a VM do Compute Engine 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 um TPU com o mesmo tamanho e versão do TensorFlow.

O procedimento treina o modelo do AmoebaNet-D no conjunto de dados fake_imagnet para um período. O treinamento leva aproximadamente 10 minutos em uma Cloud TPU v3-32. Ele será treinado para a conversão em aproximadamente 35 períodos.

Como avaliar o modelo

A avaliação precisa ser executada em apenas um dispositivo da Cloud TPU, ou seja, você precisa excluir a TPU do pod e criar um novo dispositivo da Cloud TPU. Em seguida, use essa Cloud TPU para avaliar o modelo treinado acima com relação aos dados de validação do fake_imagenet.

  1. Exclua o recurso da Cloud TPU criado para treinar o modelo em um único dispositivo.

    (vm)$ ctpu delete --project=${PROJECT_ID} \
     --tpu-only \
     --name=amoebanet-tutorial-pod \
     --zone=europe-west4-a
  2. Execute o comando ctpu up, usando o parâmetro tpu-size para especificar a Cloud TPU que você quer usar. Por exemplo, o comando a seguir usa um tipo de TPU v3-8.

    (vm)$ ctpu up --project=${PROJECT_ID} \
      --tpu-only \
      --tf-version=1.15.4 \
      --tpu-size=v3-8 \
      --name=amoebanet-tutorial-eval \
      --zone=europe-west4-a
    
  3. Atualize o diretório MODEL_BUCKET para apontar para os dados de treinamento do pod.

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/amoebanet-tutorial-pod
    (vm)$ export TPU_NAME=amoebanet-tutorial-eval
    
  4. Use as sinalizações a seguir para executar a avaliação do modelo:

    (vm)$ python3 amoeba_net.py \
     --tpu=${TPU_NAME} \
     --data_dir=${DATA_DIR} \
     --model_dir=${MODEL_DIR} \
     --num_cells=6 \
     --image_size=224 \
     --train_batch_size=4096 \
     --eval_batch_size=1000 \
     --mode=eval \
     --iterations_per_loop=1000
    

Isso gera um resultado semelhante ao seguinte:

Evaluation results: {'loss': 6.908725, 'top_1_accuracy': 0.001, 'global_step': 10955, 'top_5_accuracy': 0.005}

Como o treinamento e a avaliação foram feitos no fake_imagenet, os resultados não refletem a saída real que apareceria se o treinamento e a avaliação fossem realizados em um conjunto de dados real.

Como usar frações maiores do Pod do Cloud TPU

Você também pode testar o modelo usando frações maiores do Pod do Cloud TPU. A tabela a seguir mostra os valores recomendados para essas frações.

Parâmetro Descrição 128 núcleos 256 núcleos
num_cells Número total de células 6 6
image_size Tamanho da imagem, presumindo a altura e a largura da imagem 224 224
num_epochs Número de etapas usadas para treinamento 60 90
train_batch_size Tamanho global (não por fragmento) do lote para treinamento 8192 16384
lr Taxa de aprendizado 20,48 40,96
lr_decay_value Taxa de decaimento exponencial usada no ajuste da taxa de aprendizagem 0,91 0,94
num_shards Número de fragmentos (núcleos de TPU) 128 256

Limpar

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

  1. Exclua o Cloud TPU:

    $ ctpu delete --project=${PROJECT_ID} \
      --tpu-only \
      --name=amoebanet-tutorial-eval \
      --zone=europe-west4-a
    
  2. Desconecte-se da instância do Compute Engine, caso ainda não tenha feito isso:

    (vm)$ exit
    

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

  3. 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} \
      --vm-only \
      --name=amoebanet-tutorial \
      --zone=europe-west4-a
    
  4. 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} \
      --zone=europe-west4-a
    
    2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
    No instances currently exist.
            Compute Engine VM:     --
            Cloud TPU:             --
    
  5. 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 AmoebaNet-D 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.