Como executar o Inception na Cloud TPU

Defina como 1 para mostrar o bloco de limpeza #}

Neste tutorial, você verá como treinar o modelo do Inception (em inglês) na 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 acurácia. 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 elementos básicos 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:

image

Você encontra mais informações sobre o modelo no GitHub (em inglês).

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.

Objetivos

  • Criar um bucket do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
  • 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 Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu 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, você verá como configurar os recursos do Cloud Storage, da VM e do 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}
    
  4. Crie um bucket do Cloud Storage usando o seguinte comando: Substitua bucket-name por um nome para o bucket.

    gsutil mb -p ${PROJECT_ID} -c standard -l us-central1 -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 do 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.

  5. Inicie os recursos do Compute Engine necessários para este tutorial usando o comando ctpu up.

    ctpu up --zone=us-central1-b \
      --vm-only \
      --machine-type=n1-standard-8 \
      --tf-version=1.15.3 \
      --name=inception-tutorial
    

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

  6. 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 inception-tutorial --zone=us-central1-b
    

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

  7. Crie uma variável de ambiente para o bucket de armazenamento. Substitua bucket-name pelo nome do seu bucket no Cloud Storage.

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
  8. Crie uma variável de ambiente para o nome da TPU.

    (vm)$ export TPU_NAME=inception-tutorial

Conjunto de dados de treinamento

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.

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, é usada uma versão de demonstração do conjunto de dados completo do ImageNet, conhecido como o conjunto de dados fake_imagenet. Essa versão de demonstração permite que você teste o tutorial sem a exigência do armazenamento ou tempo necessário para fazer o download e executar um modelo no banco de dados completo do ImageNet. Veja abaixo as instruções para usar o conjunto de dados fake_imagenet gerado aleatoriamente para testar o modelo. Também é possível usar 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 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.

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

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

Configurar o TensorBoard (opcional)

No TensorBoard, há um conjunto de ferramentas projetadas para apresentar visualmente os dados do TensorFlow. Quando o TensorBoard é usado para monitoramento, é possível identificar gargalos no processamento e receber sugestões para melhorar o desempenho.

Caso não seja necessário monitorar a saída do modelo no momento, ignore as etapas de configuração do TensorBoard.

Caso queira monitorar a saída e o desempenho do modelo, siga o guia para configurar o TensorBoard.

Executar o modelo

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

Esse modelo está pré-instalado na sua VM do Compute Engine, no diretório /usr/share/tpu/models/experimental/inception/.

Nas etapas a seguir, o prefixo (vm)$ significa que é preciso 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 você estiver usando o conjunto de dados fake_imagenet:

      (vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
      
    • Se tiver feito o upload de um conjunto de dados de treinamento no bucket 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 da Cloud TPU. Observe que ctpu transmite esse nome para a VM do Compute Engine como uma variável de ambiente (TPU_NAME).
    • --use_data especifica o tipo de dados que 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 de treinamento. O aplicativo ignora esse parâmetro quando você usa 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, o programa criará uma. Ao usar uma Cloud TPU, o model_dir precisa ser um caminho do Cloud Storage (gs://...). É possível reutilizar uma pasta atual para carregar dados dos checkpoints atuais e armazenar outros checkpoints, contanto que os anteriores tenham sido criados usando uma TPU do mesmo tamanho e versão do Tensorflow.

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.

É possível usar 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, respectivamente.
  • --mode=train_and_eval especifica um job híbrido que faz treinamento e avaliação.

Os jobs somente "train" são executados para o número especificado de etapas definidas em train_steps. Se você 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 (usando as ponderações que foram treinadas até então).

O número de ciclos de treinamento é definido pela função piso (em inglês) 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 número de etapas específico. 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 checkpoints 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)

Quando a opção train_and_eval é selecionada, os jobs de treinamento e os de avaliação são executados em paralelo. Durante a avaliação, as variáveis treináveis são carregadas a partir do último checkpoint a ficar disponível. Os ciclos de treinamento e avaliação são repetidos conforme especificado nas sinalizações:

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)

Se você usou o conjunto de dados fake_imagenet para treinar o modelo, siga para a limpeza.

Como usar o conjunto de dados completo do ImageNet

O conjunto de dados do ImageNet consiste em três partes, dados de treinamento, dados de validação e rótulos de imagem.

Os dados de treinamento contêm 1.000 categorias e 1,2 milhão de imagens, empacotadas para facilitar o download. Os dados de validação e teste não estão contidos nos dados de treinamento do ImageNet (cópias foram removidas).

Os dados de validação e teste consistem em 150.000 fotografias, coletadas do flickr e de outros mecanismos de pesquisa, rotulados com a presença ou ausência de 1.000 categorias de objetos. As 1.000 categorias de objetos contêm nós internos e nós de folha do ImageNet, mas não se sobrepõem. Um subconjunto aleatório de 50.000 das imagens com rótulos foi lançado como dados de validação junto com uma lista das 1.000 categorias. As imagens restantes são usadas para avaliação e foram liberadas sem rótulos.

Etapas para pré-processar todo o conjunto de dados do ImageNet

Há cinco etapas para preparar o conjunto de dados completo do ImageNet para uso por um modelo de machine learning:

  1. Verifique se você tem espaço no destino do download.
  2. Configure os diretórios de destino.
  3. Cadastre-se no site do ImageNet e solicite permissão de download.
  4. Faça o download do conjunto de dados para o disco local ou para a VM do Compute Engine.

  5. Execute o pré-processamento e faça upload do script.

Verificar requisitos de espaço

Independentemente de fazer o download do conjunto de dados para sua máquina local ou para uma VM do Compute Engine, você precisa de cerca de 300 GB de espaço disponível no destino de download. Em uma VM, é possível verificar o armazenamento disponível com o comando df -ha.

É possível aumentar o tamanho do disco da VM usando um dos seguintes métodos:

  • Especifique a sinalização --disk-size-gb na linha de comando ctpu up com o tamanho, em GB, que você quer alocar.
  • Siga o guia do Compute Engine para adicionar um disco à VM.
    • 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.

Configurar os diretórios de destino

Na máquina local ou na VM do Compute Engine, configure a estrutura de diretórios para armazenar os dados transferidos por download.

  • Crie e exporte um diretório inicial para o conjunto de dados do ImageNet.

    Crie um diretório, por exemplo, imagenet no diretório principal da máquina ou VM local. Nesse diretório, crie dois subdiretórios: train e validation. Exporte o diretório inicial como IMAGENET_HOME:

    export IMAGENET_HOME=~/imagenet
    

Cadastrar e solicitar permissão para fazer o download do conjunto de dados

  • Cadastre-se no site do Imagenet. Só será possível fazer o download do conjunto de dados depois que o ImageNet confirmar o registro e enviar um e-mail de confirmação. Se você não receber o e-mail de confirmação em alguns dias, entre em contato com o suporte do ImageNet para saber por que seu registro não foi confirmado. Depois que seu registro for confirmado, acesse o site de download (em inglês).

Fazer o download do conjunto de dados do ImageNet

  1. No site de download, acesse a seção "Imagens" da página e clique com o botão direito do mouse em "Imagens de treinamento (Tarefa 1 e 2)". Isso fornecerá o URL necessário para fazer o download da maior parte do conjunto de treinamento. Salve o URL.

    Clique com o botão direito em "Imagens de treinamento (tarefa 3)" para ver o URL do segundo conjunto de treinamento. Salve o URL.

    Clique com o botão direito do mouse em "Imagens de validação (todas as tarefas)" para ver o URL do conjunto de dados de validação. Salve o URL.

    Se você fizer o download dos arquivos do ImageNet para a máquina local, após a conclusão do download, copie os diretórios na máquina local para o diretório $IMAGENET_HOME correspondente na VM do Compute Engine. A cópia do conjunto de dados do ImageNet do host local para sua VM leva aproximadamente 13 horas.

    Por exemplo, o comando a seguir copia todos os arquivos em $IMAGENET_HOME na máquina local para a VM que exibe o prompt do shell username@vm-name:

    gcloud compute scp --recurse $IMAGENET_HOME username@vm-name:~/imagenet
    
  2. Em $IMAGENET_HOME, use wget para fazer o download dos arquivos de treinamento e validação usando os URLs salvos.

    O arquivo de "imagens de treinamento (tarefa 1 e 2)" é o grande conjunto de treinamento. Ele tem 138 GB. Se você estiver fazendo o download em uma VM do Compute Engine usando o Cloud Shell, o tempo estimado para fazer o download será de aproximadamente 40 horas. Nesse arquivo particularmente grande, é possível preceder nohup ao comando ou usar screen para evitar que a saída de download seja desconectada se o Cloud Shell for desconectado.

    cd $IMAGENET_HOME \
    nohup wget http://image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_train.tar
    

    Isso faz o download de um arquivo tar grande: ILSVRC2012_img_train.tar.

    Na $IMAGENET_HOME na VM, extraia os diretórios de treinamento individuais no diretório $IMAGENET_HOME/train usando o comando a seguir. A extração leva de 1 a 3 horas.

    tar xf ILSVRC2012_img_train.tar
    

    O arquivo "Imagens de treinamento (Tarefa 3)" tem 728 MB e leva apenas alguns minutos para fazer o download. Assim, você não precisa tomar cuidado com a perda da conexão do Cloud Shell.

    Quando você faz o download desse arquivo, ele extrai os diretórios de treinamento individuais para o diretório $IMAGENET_HOME/train atual.

    wget http://www.image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_train_t3.tar
    

    O arquivo "Imagens de validação (todas as tarefas)" é de 6 GB. Portanto, convém usar nohup ou screen para evitar que a saída de download seja desconectada se o Cloud Shell for desconectado.

    wget http://www.image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_val.tar
    

    Esse download leva cerca de 30 minutos. Quando você faz o download desse arquivo, ele extrai os diretórios de validação individuais para o diretório $IMAGENET_HOME/validation.

    Se você tiver feito o download dos arquivos de validação para a máquina local, copie o diretório $IMAGENET_HOME/validation na máquina local para o diretório $IMAGENET_HOME/validation na VM do Compute Engine. Essa operação de cópia leva cerca de 30 minutos.

    Faça o download do arquivo de rótulos. Isso leva apenas alguns segundos.

    wget -O $IMAGENET_HOME/synset_labels.txt \
    https://raw.githubusercontent.com/tensorflow/models/master/research/inception/inception/data/imagenet_2012_validation_synset_labels.txt
    

    Se você fez o download do arquivo de rótulos na máquina local, precisa copiá-lo para o diretório $IMAGENET_HOME na máquina local para $IMAGENET_HOME na VM do Compute Engine. Essa operação de cópia leva alguns segundos.

    Os nomes dos subdiretórios de treinamento (por exemplo, n03062245) são "IDs do WordNet" (wnid). A API ImageNet (em inglês) mostra o mapeamento de IDs do WordNet para seus rótulos de validação associados no arquivo synset_labels.txt. Uma sincronia nesse contexto é um grupo visualmente semelhante de imagens.

Processar o conjunto de dados ImageNet e, opcionalmente, fazer upload para o Cloud Storage

  1. No GitHub, faça o download do script imagenet_to_gcs.py:

    wget https://raw.githubusercontent.com/tensorflow/tpu/master/tools/datasets/imagenet_to_gcs.py
    
  2. Se você estiver fazendo upload do conjunto de dados para o Cloud Storage, especifique o local do intervalo de armazenamento para fazer upload do conjunto de dados do ImageNet:

    export STORAGE_BUCKET=gs://bucket-name
    
  3. Se você estiver fazendo o upload do conjunto de dados para o Cloud Storage, especifique um diretório de dados do bucket de armazenamento para armazenar o conjunto de dados:

    (vm)$ export DATA_DIR=$STORAGE_BUCKET/dataset-directory
    
  4. Execute o script para pré-processar o conjunto de dados brutos como TFRecords e faça o upload dele no Cloud Storage usando o seguinte comando:

     python3 imagenet_to_gcs.py \
      --project=$PROJECT \
      --gcs_output_path=$DATA_DIR  \
      --raw_data_dir=$IMAGENET_HOME \
      --local_scratch_dir=$IMAGENET_HOME/tf_records
    

O script gera um conjunto de 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

Depois que os dados forem enviados para seu bucket do Cloud, execute seu modelo e defina --data_dir=${DATA_DIR}.

Realizar a limpeza

As etapas abaixo mostram como evitar cobranças na sua conta do GCP pelo uso de recursos.

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

    (vm)$ exit
    

    Agora, o prompt precisa ser username@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 [optional: --zone]
    
  3. 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 --zone=europe-west4-a
    
    2018/04/28 16:16:23 WARNING: Setting zone to "--zone=europe-west4-a"
    No instances currently exist.
        Compute Engine VM:     --
        Cloud TPU:             --
    
  4. Execute gsutil conforme mostrado. Substitua bucket-name pelo nome do bucket do Cloud Storage criado para este tutorial:

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

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 está pré-instalado na sua VM do Compute Engine, no diretório /usr/share/tpu/models/experimental/inception/.

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

  1. Se o TensorBoard estiver em execução na guia do Cloud Shell, você precisará de outra guia para trabalhar. Abra outra guia no Cloud Shell e use 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 você estiver usando o conjunto de dados fake_imagenet:

      (vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
      
    • Se tiver feito o upload de um conjunto de dados de treinamento no bucket 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 da Cloud TPU. Observe que ctpu transmite esse nome para a VM do Compute Engine como uma variável de ambiente (TPU_NAME).
    • --use_data especifica o tipo de dados que 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 de treinamento. O aplicativo ignora esse parâmetro quando você usa 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, o programa criará uma. Ao usar uma Cloud TPU, o model_dir precisa ser um caminho do Cloud Storage (gs://...). É possível reutilizar uma pasta atual para carregar dados dos checkpoints atuais e armazenar outros checkpoints, contanto que os anteriores tenham sido criados usando uma TPU do mesmo tamanho e versão do Tensorflow.

Como fazer a limpeza

A seguir

## A seguir {: #whats-next } Neste tutorial, você treinou o modelo Inception 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.