Esta página foi traduzida pela API Cloud Translation.

Como treinar Mask RCNN no Cloud TPU (TF 2.x)

Visão geral

Este tutorial demonstra como executar o modelo Mask RCNN usando o Cloud TPU. com o conjunto de dados COCO.

O Mask RCNN é uma rede neural profunda projetada para lidar com a detecção de objetos e a segmentação de imagens, um dos desafios mais difíceis da visão computacional.

O modelo Mask RCNN gera caixas delimitadoras e máscaras de segmentação para cada instância de um objeto na imagem. O modelo é baseado Rede de pirâmide de recursos (FPN, na sigla em inglês) e um backbone ResNet50.

Neste tutorial, usamos a API Keras do Tensorflow para treinar o modelo. A Keras é uma API de alto nível do TensorFlow que pode ser usada para criar e executar um de machine learning no Cloud TPU. A API simplifica o desenvolvimento do modelo escondendo grande parte da implementação de nível inferior, o que facilita alternar entre a TPU e outras plataformas, como GPU ou CPU.

Estas instruções pressupõem que você já esteja familiarizado com o treinamento de um modelo Cloud TPU: Se você nunca usou o Cloud TPU, confira estas instruções: consulte o Guia de início rápido para uma introdução básica.

Objetivos

Preparar o conjunto de dados COCO
Criar um bucket do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
Configurar recursos de 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 documento, você usará os seguintes componentes faturáveis do Google Cloud:

Compute Engine
Cloud TPU
Cloud Storage

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. 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.

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

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

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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.

Preparar o conjunto de dados COCO

Este tutorial usa o conjunto de dados COCO. O conjunto de dados precisa estar no formato TFRecord em um bucket do Cloud Storage para ser usado no treinamento.

Se você já preparou o conjunto de dados COCO em um bucket do Cloud Storage que está localizado na zona que você usará para treinar o modelo, acesse diretamente o treinamento de dispositivo único. Caso contrário, siga as etapas abaixo para preparar o conjunto de dados.

Abra uma janela do Cloud Shell.

Abrir o Cloud Shell

No Cloud Shell, configure o gcloud com seu projeto ID.

export PROJECT_ID=project-id
gcloud config set project ${PROJECT_ID}

No Cloud Shell, crie um bucket do Cloud Storage usando o seguinte comando:

Observação: no comando a seguir, substitua bucket-name pelo nome que você quer atribuir ao bucket.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
Inicie uma instância de VM do Compute Engine.

Essa instância de VM só será usada para fazer o download e o pré-processamento do conjunto de dados COCO. Preencha instance-name com o nome de sua escolha.
```
$ gcloud compute tpus execution-groups create \
 --vm-only \
 --name=instance-name \
 --zone=europe-west4-a \
 --disk-size=300 \
 --machine-type=n1-standard-16 \
 --tf-version=2.17.0
```
Descrições de sinalizações de comando

vm-only

Crie somente uma VM. Por padrão, o comando gcloud compute tpus execution-groups cria uma VM e uma Cloud TPU.

name

O nome da Cloud TPU a ser criada.

zone

A zona em que você planeja criar a Cloud TPU.

disk-size

O tamanho do disco rígido em GB da VM criada pelo comando gcloud compute tpus execution-groups .

machine-type

O tipo de máquina da VM do Compute Engine a ser criado.

tf-version

A versão do gcloud compute tpus execution-groups do Tensorflow é instalada na VM.
Se você não for conectado automaticamente à instância do Compute Engine, faça login executando o seguinte comando ssh. Quando você faz login na VM, o prompt do shell muda de username@projectname para username@vm-name:
```
  $ gcloud compute ssh instance-name --zone=europe-west4-a
  
```
Configure duas variáveis, uma para o bucket de armazenamento criado anteriormente e outra para o diretório que contém os dados de treinamento (DATA_DIR) no bucket de armazenamento.
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```

Instale os pacotes necessários para pré-processar os dados.

(vm)$ sudo apt-get install -y python3-tk && \
  pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow && \
  pip3 install --user "git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI"

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)$ git clone https://github.com/tensorflow/tpu.git
(vm)$ sudo bash tpu/tools/datasets/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 de download e conversão do COCO leva aproximadamente 1 hora para ser concluído.
Copie os dados para o bucket do Cloud Storage

Depois de converter os dados para TFRecords, copie-os do armazenamento local ao bucket do Cloud Storage usando a CLI gcloud. Você deve copiar os arquivos de anotação. Esses arquivos ajudam a validar o comportamento desempenho.
```
(vm)$ gcloud storage cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gcloud storage cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```
Limpar os recursos da VM

Depois que o conjunto de dados COCO for convertido em TFRecords e copiado para o DATA_DIR no bucket do Cloud Storage, será possível excluir a instância do Compute Engine.

Desconecte-se da instância do Compute Engine:
```
(vm)$ exit
```
Agora, o prompt precisa ser username@projectname, mostrando que você está no Cloud Shell.

Exclua a instância do Compute Engine.

  $ gcloud compute instances delete instance-name
    --zone=europe-west4-a

Treinamento de dispositivo único do Cloud TPU

Abra uma janela do Cloud Shell.

Abrir o Cloud Shell
Crie uma variável de ambiente para o código do projeto.
```
export PROJECT_ID=project-id
```
Configure a CLI do Google Cloud para usar o projeto em que você quer criar o Cloud TPU:
```
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 de baixo. da página para permitir que gcloud faça chamadas de API do Google Cloud com suas credenciais.

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 seguinte formato:

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

Exportar variáveis de configuração da TPU

Exporte o ID do projeto, o nome que você quer usar para os recursos de TPU, e a zona em que você vai treinar o modelo e armazenar todos os dados relacionados ao treinamento.
```
$ export TPU_NAME=mask-rcnn-tutorial
$ export ZONE=europe-west4-a
```
Iniciar uma VM do Compute Engine e um Cloud TPU.
```
$ gcloud compute tpus tpu-vm create mask-rcnn-tutorial \
   --zone=${ZONE} \
   --accelerator-type=v3-8 \
   --version=tpu-vm-tf-2.17.0-pjrt
  
```
Descrições de sinalizações de comando

zone

A zona em que você planeja criar a Cloud TPU.

accelerator-type

O tipo de acelerador especifica a versão e o tamanho do Cloud TPU que você quer criar. Para mais informações sobre os tipos de aceleradores compatíveis com cada versão de TPU, consulte versões de TPU.

version

A versão do software do Cloud TPU.

Observação: na primeira vez que você cria uma VM da TPU em um projeto, ela vários minutos para executar tarefas de inicialização, como propagação de chave SSH e ativação de API.

Para mais informações sobre o comando gcloud, consulte a referência da gcloud.
Conecte-se à instância do Compute Engine usando SSH. Quando você estiver conectado para a VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh mask-rcnn-tutorial --zone=${ZONE}
```
Importante :a partir deste ponto, o prefixo (vm) $ significa que é necessário executar o comando na instância de VM do Compute Engine.

Instale os requisitos do TensorFlow.

(vm)$ pip3 install -r /usr/share/tpu/models/official/requirements.txt

Defina a variável de nome da Cloud TPU.
```
(vm)$ export TPU_NAME=local
```
Configure as seguintes variáveis de ambiente, substituindo bucket-name pelo nome do bucket do Cloud Storage que armazena o conjunto de dados COCO:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```

Adicione variáveis de ambiente aos diretórios de dados e modelos.

(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mask-rcnn

Adicione mais algumas variáveis de ambiente necessárias:

(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
(vm)$ export TRAIN_FILE_PATTERN=${DATA_DIR}/train-*
(vm)$ export EVAL_FILE_PATTERN=${DATA_DIR}/val-*
(vm)$ export VAL_JSON_FILE=${DATA_DIR}/instances_val2017.json

Defina a variável de ambiente PYTHONPATH:

(vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/tpu/models"

Ao criar sua TPU, se você definir o parâmetro --version como uma versão que termina com -pjrt, defina as seguintes variáveis de ambiente para ativar o ambiente de execução PJRT:
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```

Mude para o diretório que armazena o modelo:

(vm)$ cd /usr/share/tpu/models/official/vision

O script a seguir executa um treinamento de amostra com 10 etapas de treinamento e 10 etapas de avaliação. Ela leva aproximadamente 6 minutos para ser concluída TPU v3-8. O treinamento para convergência leva cerca de 22.500 etapas horas em uma TPU v3-8.

Execute o seguinte comando para treinar o modelo Mask-RCNN:

(vm)$ python3 train.py \
  --tpu=${TPU_NAME} \
  --experiment=maskrcnn_resnetfpn_coco \
  --mode=train_and_eval \
  --config_file=configs/experiments/maskrcnn/r50fpn_640_coco_scratch_tpu4x4.yaml \
  --model_dir=${MODEL_DIR} \
  --params_override="task.train_data.input_path=${TRAIN_FILE_PATTERN},task.validation_data.input_path=${EVAL_FILE_PATTERN},task.annotation_file=${VAL_JSON_FILE},runtime.distribution_strategy=tpu,trainer.train_steps=10,trainer.validation_steps=10,task.train_data.global_batch_size=8,task.validation_data.global_batch_size=8"

Descrições de sinalizações de comando

strategy_type: A estratégia de distribuição.
tpu: O nome da TPU.
model_dir: Especifica o diretório em que os checkpoints e resumos são armazenados durante treinamento de modelo. Se a pasta não existir, o programa criará um. Ao usar um Cloud TPU, o model_dir precisa ser um caminho do Cloud Storage (`gs://...`). É possível reutilizar um pasta existente para carregar os dados do checkpoint atual e armazenar pontos de verificação adicionais, contanto que os pontos de verificação anteriores tenham usando uma TPU do mesmo tamanho e versão do TensorFlow.

Quando o treinamento for concluído, aparecerá uma mensagem semelhante à seguinte:

{'frcnn_box_loss': 0.033865165,
 'frcnn_cls_loss': 1.2535654,
 'learning_rate': 0.008266499,
 'mask_loss': 1.2039567,
 'model_loss': 2.821458,
 'rpn_box_loss': 0.034982488,
 'rpn_score_loss': 0.2950886,
 'total_loss': 4.340171,
 'training_loss': 4.340171}
train | step:     10 | steps/sec:    0.1 | output:
{'frcnn_box_loss': 0.033865165,
 'frcnn_cls_loss': 1.2535654,
 'learning_rate': 0.008266499,
 'mask_loss': 1.2039567,
 'model_loss': 2.821458,
 'rpn_box_loss': 0.034982488,
 'rpn_score_loss': 0.2950886,
 'total_loss': 4.340171,
 'training_loss': 4.340171}

Isso é seguido pela saída das etapas de avaliação.

Você concluiu o treinamento e a avaliação de um dispositivo único. Use o etapas a seguir para excluir os recursos atuais de TPU de um único dispositivo.

Desconecte-se da instância do Compute Engine:
```
(vm)$ exit
```
Agora, o prompt precisa ser username@projectname, mostrando que você está no Cloud Shell.
Exclua o recurso da TPU.
```
$ gcloud compute tpus tpu-vm delete mask-rcnn-tutorial \
    --zone=europe-west4-a
```
Descrições de sinalizações de comando

zone

A zona onde o Cloud TPU residia.

Neste ponto, é possível concluir este tutorial e limpar ou continuar executando o modelo nos Pods do Cloud TPU.

Como escalonar o modelo com os pods da Cloud TPU

O treinamento do seu modelo em pods da Cloud TPU pode exigir algumas alterações ao script de treinamento. Para mais informações, consulte Treinamento em pods de TPU.

Treinamento do pod de TPU

Abra uma janela do Cloud Shell.

Abrir o Cloud Shell
Crie uma variável para o ID do seu projeto.
```
export PROJECT_ID=project-id
```
Configurar a CLI do Google Cloud para usar o projeto em que você quer criar Cloud TPU:
```
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 de baixo. da página para permitir que gcloud faça chamadas de API do Google Cloud com suas credenciais.
Crie uma conta de serviço para o projeto da Cloud TPU.

As contas de serviço permitem que o serviço do Cloud TPU acesse outros serviços do Google Cloud.
```
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 seguinte formato:
```
service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
```
Se você preparou anteriormente o conjunto de dados COCO e o moveu para seu armazenamento em um bucket, é possível usá-lo novamente no treinamento de pods. Se você ainda não se preparou o conjunto de dados COCO, prepare-o agora e volte aqui para configurar no treinamento.
Inicie um pod do Cloud TPU

Neste tutorial, especificamos um pod v3-32. Para outras opções de pods, consulte versões de TPU.

Observação: se não houver capacidade suficiente disponível no momento para criar o pod de TPU, será possível enfileirar sua solicitação usando recursos na fila. Recursos na fila permitem que você receba a capacidade quando ela for disponibilizado. Para solicitar os recursos do Cloud TPU como recursos na fila, use o gcloud compute tpus queued-resources create. Para mais informações, consulte Gerenciar recursos na fila.
```
$ gcloud compute tpus tpu-vm create mask-rcnn-tutorial \
  --zone=${ZONE} \
  --accelerator-type=v3-32 \
  --version=tpu-vm-tf-2.17.0-pod-pjrt
```
Descrições de sinalizações de comando

zone

A zona em que você planeja criar a Cloud TPU.

accelerator-type

O tipo de acelerador especifica a versão e o tamanho do Cloud TPU que você quer criar. Para mais informações sobre os tipos de aceleradores compatíveis com cada versão de TPU, consulte versões de TPU.

version

A versão do software do Cloud TPU.

Observação: na primeira vez que você executar gcloud em um projeto, leva cerca de 5 minutos para executar tarefas de inicialização, como chaves SSH. propagação e ativação da API.
Observação: a primeira vez que você executar gcloud em um projeto, vai levar cerca de cinco minutos. para executar tarefas de inicialização, como propagação de chave SSH e ativação de API.
Conecte-se à instância do Compute Engine usando SSH. Quando você estiver conectado para a VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh mask-rcnn-tutorial --zone=${ZONE}
```
Importante: a partir deste ponto, o prefixo (vm) $ significa que você deve executar o comando na instância de VM do Compute Engine.

Instale os requisitos do TensorFlow.

(vm)$ pip3 install -r /usr/share/tpu/models/official/requirements.txt

O script de treinamento requer um pacote extra. Instalar agora.

(vm)$ pip3 install --user tensorflow-model-optimization>=0.1.3

Defina a variável de nome da Cloud TPU.

(vm)$ export TPU_NAME=mask-rcnn-tutorial

Configure as seguintes variáveis de ambiente, substituindo bucket-name pelo nome do bucket do Cloud Storage:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```

Adicione mais algumas variáveis de ambiente necessárias:

(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(vm)$ export TRAIN_FILE_PATTERN=${DATA_DIR}/train-*
(vm)$ export EVAL_FILE_PATTERN=${DATA_DIR}/val-*
(vm)$ export VAL_JSON_FILE=${DATA_DIR}/instances_val2017.json
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mask-rcnn-pod

Defina a variável de ambiente PYTHONPATH:

(vm)$ export PYTHONPATH="/usr/share/tpu/models:${PYTHONPATH}"
(vm)$ export TPU_LOAD_LIBRARY=0

Mude para o diretório que armazena o modelo:

(vm)$ cd /usr/share/tpu/models/official/vision

(vm)$ cd /usr/share/models/official/legacy/detection

Treinar o modelo:

Este procedimento treina o modelo no conjunto de dados COCO de 10 etapas de treinamento. O treinamento leva aproximadamente 10 minutos em um Cloud TPU v3-32.

Observação: após o início do treinamento, é possível verificar se ele está em execução monitorando a atividade da TPU no Console do Cloud TPU. No Compute Engine -> TPUs, clique sua entrada na TPU. Isso abrirá uma página com a configuração de TPU detalhes e um link para MONITORING. Clique em MONITORAR para ver a Atividade da TPU.
```
(vm)$ python3 train.py \
  --tpu=${TPU_NAME} \
  --experiment=maskrcnn_resnetfpn_coco \
  --mode=train_and_eval \
  --config_file=configs/experiments/maskrcnn/r50fpn_640_coco_scratch_tpu4x4.yaml \
  --model_dir=${MODEL_DIR} \
  --params_override="task.train_data.input_path=${TRAIN_FILE_PATTERN},task.validation_data.input_path=${EVAL_FILE_PATTERN},task.annotation_file=${VAL_JSON_FILE},runtime.distribution_strategy=tpu,trainer.train_steps=10,trainer.validation_steps=10,task.train_data.global_batch_size=256,task.validation_data.global_batch_size=256"
```
Descrições de sinalizações de comando

tpu

O nome da TPU.

model_dir

Especifica o diretório em que os pontos de controle e os resumos são armazenados durante o treinamento de 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://...). Você pode reutilizar uma pasta existente para carregar os dados do checkpoint atual e armazenar pontos de verificação adicionais, contanto que os pontos de verificação anteriores tenham usando uma Cloud TPU do mesmo tamanho e TensorFlow para a versão anterior.

params_override

Uma string JSON que modifica parâmetros de script padrão.

Quando o treinamento for concluído, uma mensagem semelhante a esta será exibida:

 I0706 19:47:16.108213 139955064548416 controller.py:457] train | step: 10 | steps/sec:    0.1 | output:
    {'frcnn_box_loss': 0.05632668,
     'frcnn_cls_loss': 1.3012192,
     'learning_rate': 0.008266499,
     'mask_loss': 1.2371812,
     'model_loss': 2.9746659,
     'rpn_box_loss': 0.08227444,
     'rpn_score_loss': 0.2976642,
     'total_loss': 4.493513,
     'training_loss': 4.493513}
train | step:     10 | steps/sec:    0.1 | output:
    {'frcnn_box_loss': 0.05632668,
     'frcnn_cls_loss': 1.3012192,
     'learning_rate': 0.008266499,
     'mask_loss': 1.2371812,
     'model_loss': 2.9746659,
     'rpn_box_loss': 0.08227444,
     'rpn_score_loss': 0.2976642,
     'total_loss': 4.493513,
     'training_loss': 4.493513}

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Depois de executar o treinamento, exclua a VM da TPU e remova o bucket de armazenamento.

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. O comando agora será username@projectname, mostrando que você está no o Cloud Shell.

Exclua os recursos do Cloud TPU e do Compute Engine.

$ gcloud compute tpus tpu-vm delete mask-rcnn-tutorial \
--zone=${ZONE}

Execute gcloud compute tpus tpu-vm list para verificar se os recursos foram excluídos. A exclusão pode levar vários minutos. A saída do comando a seguir não deve incluir nenhum dos recursos de TPU criados neste tutorial:
```
$ gcloud compute tpus tpu-vm list --zone=${ZONE}
```
Execute a CLI gcloud conforme mostrado, substituindo bucket-name por o nome do bucket do Cloud Storage criado para este tutorial:
```
$ gcloud storage rm gs://bucket-name --recursive
```

A seguir

Geralmente, os tutoriais do Cloud TPU do TensorFlow treinam o modelo usando um conjunto de dados de amostra. Os resultados desse treinamento não são utilizáveis para inferência. Para usar um modelo para inferência, é possível treinar os dados em uma conjunto de dados ou seu próprio conjunto de dados. Modelos do TensorFlow treinados em Cloud TPUs geralmente exigem que os conjuntos de dados estejam TFRecord.

Você pode usar a ferramenta de conversão do conjunto de dados sample para converter uma imagem conjunto de dados de classificação no formato TFRecord. Se você não estiver usando uma imagem modelo de classificação, você terá que converter seu conjunto de dados para Formato do TFRecord você mesmo. 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 a e ajustar os hiperparâmetros. É possível encontrar informações sobre hiperparâmetros comuns a todos Modelos com suporte a TPU em GitHub. As informações sobre hiperparâmetros específicos do modelo podem ser encontradas na fonte para cada um modelo de machine learning. Para mais informações sobre o ajuste de hiperparâmetros, consulte a Visão geral do ajuste de hiperparâmetros e Ajuste e ajustar os hiperparâmetros.

Inferência

Depois de treinar o modelo, você pode usá-lo para inferência (também chamado de previsão). Use o conversor de inferência do Cloud TPU ferramenta para preparar e otimizar Modelo do TensorFlow para inferência no Cloud TPU v5e. Para mais informações sobre inferência no Cloud TPU v5e, consulte Inferência do Cloud TPU v5e introdução.

Conheça as ferramentas de TPU no TensorBoard.