Como executar o Inception no Cloud TPU

Neste tutorial, você aprende a treinar o modelo do Inception 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.

Descrição do modelo

O Inception v3 é um modelo de reconhecimento de imagem muito usado que atinge uma enorme precisão. Esse modelo é o auge de muitas ideias desenvolvidas por vários pesquisadores ao longo dos anos. Ele é baseado no documento original "Rethinking the Inception Architecture for Computer Vision", de Szegedy e outros autores.

O modelo inclui componentes simétricos e assimétricos como:

  • convoluções;
  • pool médio;
  • pool máximo;
  • concatenações;
  • dropouts;
  • camadas totalmente conectadas.

A perda é calculada por meio da função softmax.

A imagem a seguir mostra o modelo em detalhes:

imagem

Você encontra mais informações sobre o modelo no GitHub.

O modelo foi criado usando a avançada API Estimator.

A API simplifica a criação do modelo ao encapsular a maioria das funções de nível baixo. Isso possibilita que os usuários se concentrem no desenvolvimento de modelos, e não no funcionamento interno do hardware subjacente responsável por execuções.

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.

Conseguir os dados

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

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.

Você pode usar dois conjuntos de dados: um fictício e gerado aleatoriamente ou o conjunto de dados completo do ImageNet. Usamos a variável de ambiente DATA_DIR descrita abaixo para especificar em qual conjunto de dados faremos o treinamento.

O conjunto de dados fictício é útil apenas para entender como usar um Cloud TPU e validar o desempenho de ponta a ponta. Os números de precisão e o modelo salvo não são importantes.

Você encontra o conjunto de dados fictício neste local no Cloud Storage:

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

Configurar o TensorBoard

Antes de treinar o modelo, inicie o TensorBoard em segundo plano para ver o andamento do programa de treinamento:

(vm)$ tensorboard --logdir=${STORAGE_BUCKET}/inception &

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.

Executar o modelo

Agora você está pronto para treinar e avaliar o modelo do Inception v3 usando os dados do ImageNet.

O modelo do Inception v3 vem pré-instalado na VM do Compute Engine no diretório /usr/share/tpu/models/experimental/inception/.

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

  1. Configure uma variável de ambiente DATA_DIR que contenha um dos valores a seguir:

    • Se estiver usando o conjunto de dados fictício:

      (vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
      

    • Se tiver feito o upload de um conjunto de dados de treinamento no intervalo do Cloud Storage:

      (vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
      

  2. Execute o modelo do Inception v3:

    (vm)$ python /usr/share/tpu/models/experimental/inception/inception_v3.py \
        --tpu=$TPU_NAME \
        --learning_rate=0.165 \
        --train_steps=250000 \
        --iterations=500 \
        --use_tpu=True \
        --use_data=real \
        --mode=train_and_eval \
        --train_steps_per_eval=2000 \
        --data_dir=${DATA_DIR} \
        --model_dir=${STORAGE_BUCKET}/inception

    • --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).
    • --use_data especifica que tipo de dados o programa precisa usar durante o treinamento, seja fictício ou real. O valor padrão é fictício.
    • --data_dir especifica o caminho do Cloud Storage para a entrada do treinamento. O aplicativo ignora esse parâmetro quando você usa dados fictícios.
    • --model_dir especifica o diretório em que os pontos de verificação e resumos são armazenados durante o treinamento do modelo. Se a pasta não existir, o programa criará uma. Ao usar um Cloud TPU, o model_dir precisa ser um caminho do Cloud Storage (gs://...). É possível reutilizar uma pasta existente para carregar os dados do ponto de verificação atual e armazenar novos pontos.

O que esperar

O Inception v3 funciona em imagens 299 x 299. O tamanho de lote padrão do treinamento é 1024. Isso significa que cada iteração opera em 1024 dessas imagens.

Use a sinalização --mode para selecionar um dos três modos de operação: "train", "eval" e "train_and_eval":

  • --mode=train ou --mode=eval especificam um job somente de treinamento ou de avaliação;
  • --mode=train_and_eval especifica um job híbrido que faz treinamento e avaliação.

Os jobs somente "train" são executados no número de etapas específico definido em train_steps. Se quiser, eles podem passar por todo o conjunto de treinamento.

Os jobs "train_and_eval" são ciclos com segmentos de treinamento e avaliação. Cada ciclo de treinamento é executado em train_steps_per_eval e seguido por um job de avaliação, que usa os pesos treinados até então.

O número de ciclos de treinamento é definido pela função floor de train_steps dividido por train_steps_per_eval.

floor(train_steps / train_steps_per_eval)

Por padrão, os modelos baseados na API Estimator informam os valores de perda a cada determinado número de etapas. O formato do relatório é similar a este:

step = 15440, loss = 12.6237

Discussão: modificações específicas da TPU no modelo

Preparar os modelos baseados na API Estimator requer bem poucas modificações específicas. O programa importa as bibliotecas a seguir:

from google.third_party.tensorflow.contrib.tpu.python.tpu import tpu_config
from google.third_party.tensorflow.contrib.tpu.python.tpu import tpu_estimator
from google.third_party.tensorflow.contrib.tpu.python.tpu import tpu_optimizer

A função "CrossShardOptimizer" encapsula o otimizador assim:

if FLAGS.use_tpu:
  optimizer = tpu_optimizer.CrossShardOptimizer(optimizer)

A função que define o modelo retorna uma especificação da Estimator usando:

return tpu_estimator.TPUEstimatorSpec(
    mode=mode, loss=loss, train_op=train_op, eval_metrics=eval_metrics)

A função principal define uma configuração compatível com a Estimator usando:

run_config = tpu_config.RunConfig(
    master=tpu_grpc_url,
    evaluation_master=tpu_grpc_url,
    model_dir=FLAGS.model_dir,
    save_checkpoints_secs=FLAGS.save_checkpoints_secs,
    save_summary_steps=FLAGS.save_summary_steps,
    session_config=tf.ConfigProto(
        allow_soft_placement=True,
        log_device_placement=FLAGS.log_device_placement),
    tpu_config=tpu_config.TPUConfig(
        iterations_per_loop=iterations,
        num_shards=FLAGS.num_shards,
        per_host_input_for_training=per_host_input_for_training))

O programa usa essa configuração definida e uma função de definição de modelo para criar um objeto da Estimador:

inception_classifier = tpu_estimator.TPUEstimator(
    model_fn=inception_model_fn,
    use_tpu=FLAGS.use_tpu,
    config=run_config,
    params=params,
    train_batch_size=FLAGS.train_batch_size,
    eval_batch_size=eval_batch_size,
    batch_axis=(batch_axis, 0))

Os jobs somente "train" precisam chamar apenas a função de treinamento:

inception_classifier.train(
    input_fn=imagenet_train.input_fn, steps=FLAGS.train_steps)

Os jobs somente "eval" recebem os dados dos pontos de verificação disponíveis e aguardam até que outro também fique disponível:

for checkpoint in get_next_checkpoint():
  eval_results = inception_classifier.evaluate(
      input_fn=imagenet_eval.input_fn,
      steps=eval_steps,
      hooks=eval_hooks,
      checkpoint_path=checkpoint)

Os jobs híbridos "train_and_eval" executam treinamento e avaliação. O modelo é avaliado por meio do conjunto atual de variáveis treináveis de um ponto de verificação. Os ciclos de treinamento e avaliação se repetem conforme especificado pelo usuário:

for cycle in range(FLAGS.train_steps // FLAGS.train_steps_per_eval):
  inception_classifier.train(
      input_fn=imagenet_train.input_fn, steps=FLAGS.train_steps_per_eval)

  eval_results = inception_classifier.evaluate(
      input_fn=imagenet_eval.input_fn, steps=eval_steps, hooks=eval_hooks)

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.

Como usar o conjunto de dados completo do ImageNet

Você precisa de aproximadamente 300 GB de espaço livre na máquina local ou VM para executar o script usado nesta seção.

Se você quiser processar os dados na VM do Compute Engine, siga estas etapas para adicionar espaço em disco a ela:

  • Siga o guia do Compute Engine para adicionar um disco à VM.
  • Defina o tamanho do disco como 300 GB ou mais.
  • Defina Ao excluir uma instância como Excluir disco para garantir que o disco seja removido quando você excluir a VM.
  • Anote o caminho do novo disco. Por exemplo: /mnt/disks/mnt-dir.

Para fazer o download do conjunto de dados completo do ImageNet, convertê-lo e carregá-lo para o Cloud Storage:

  1. Inscreva-se em uma conta do ImageNet. Lembre-se do nome de usuário e senha que você usou para criar a conta.

  2. Configure uma variável de ambiente DATA_DIR que aponta para um caminho no intervalo do Cloud Storage:

    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
    

  3. Faça o download do script imagenet_to_gcs.py do GitHub:

    $ wget https://raw.githubusercontent.com/tensorflow/tpu/master/tools/datasets/imagenet_to_gcs.py
    

  4. Defina uma variável SCRATCH_DIR para conter os arquivos de trabalho do script. A variável precisa especificar uma localização na máquina local ou na VM do Compute Engine. Por exemplo, na máquina local:

    $ SCRATCH_DIR=./imagenet_tmp_files
    

    Ou se você estiver processando os dados na VM:

    (vm)$ SCRATCH_DIR=/mnt/disks/mnt-dir/imagenet_tmp_files
    

  5. Execute o script imagenet_to_gcs.py para fazer o download, formatar e carregar os dados do ImageNet para o intervalo. Substitua YOUR-USERNAME e YOUR-PASSWORD pelo nome de usuário e senha que você usou para criar a conta do ImageNet.

    $ pip install google-cloud-storage
    $ python imagenet_to_gcs.py \
      --project=$PROJECT \
      --gcs_output_path=$DATA_DIR \
      --local_scratch_dir=$SCRATCH_DIR \
      --imagenet_username=YOUR-USERNAME \
      --imagenet_access_key=YOUR-PASSWORD
    

Observação: o download e o pré-processamento dos dados podem levar até 12 horas, dependendo da velocidade da rede e do computador. Não interrompa o script.

Quando o script terminar o processamento, uma mensagem como esta será exibida:

2018-02-17 14:30:17.287989: Finished writing all 1281167 images in data set.

O script produz vários diretórios para treinamento e validação do formulário:

${DATA_DIR}/train-00000-of-01024
${DATA_DIR}/train-00001-of-01024
 ...
${DATA_DIR}/train-01023-of-01024

e

${DATA_DIR}/validation-00000-of-00128
S{DATA_DIR}/validation-00001-of-00128
 ...
${DATA_DIR}/validation-00127-of-00128

Inception v4

O modelo do Inception v4 é de rede neural profunda. Ele usa componentes do Inception v3 para alcançar uma precisão maior. O modelo é descrito no artigo "Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning", de Szegedy e outros autores.

O modelo do Inception v4 vem pré-instalado na VM do Compute Engine no diretório /usr/share/tpu/models/experimental/inception/.

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

  1. Se tiver o TensorBoard em execução na guia do Cloud Shell, você precisará de outra para trabalhar. Abra outra guia no Cloud Shell e use o ctpu no novo shell para se conectar à VM do Compute Engine:

    $ ctpu up

  2. Configure uma variável de ambiente DATA_DIR que contenha um dos valores a seguir:

    • Se estiver usando o conjunto de dados fictício:

      (vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
      

    • Se tiver feito o upload de um conjunto de dados de treinamento no intervalo do Cloud Storage:

      (vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
      

  3. Execute o modelo do Inception v4:

    (vm)$ python /usr/share/tpu/models/experimental/inception/inception_v4.py \
        --tpu=$TPU_NAME \
        --learning_rate=0.36 \
        --train_steps=1000000 \
        --iterations=500 \
        --use_tpu=True \
        --use_data=real \
        --train_batch_size=256 \
        --mode=train_and_eval \
        --train_steps_per_eval=2000 \
        --data_dir=${DATA_DIR} \
        --model_dir=${STORAGE_BUCKET}/inception

    • --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).
    • --use_data especifica que tipo de dados o programa precisa usar durante o treinamento, seja fictício ou real. O valor padrão é fictício.
    • --train_batch_size especifica o tamanho do lote de treinamento como 256. Como o modelo do Inception v4 é maior que o do v3, ele precisa ser executado em um tamanho de lote menor por núcleo de TPU.
    • --data_dir especifica o caminho do Cloud Storage para a entrada do treinamento. O aplicativo ignora esse parâmetro quando você usa dados fictícios.
    • --model_dir especifica o diretório em que os pontos de verificação e resumos são armazenados durante o treinamento do modelo. Se a pasta não existir, o programa criará uma. Ao usar um Cloud TPU, o model_dir precisa ser um caminho do Cloud Storage (gs://...). É possível reutilizar uma pasta existente para carregar os dados do ponto de verificação atual e armazenar novos pontos.

Próximas etapas

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

Enviar comentários sobre…