Esta página foi traduzida pela API Cloud Translation.

Treinamento do RetinaNet na Cloud TPU (TF 2.x)

Neste documento, descrevemos uma implementação do modelo de detecção de objetos do RetinaNet. O código está disponível no GitHub.

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, consulte Treinamento em pods de TPU para entender as mudanças de parâmetros necessárias para frações de pod.

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.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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á tem o conjunto de dados COCO preparado em um bucket do Cloud Storage localizado na zona que será usada 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=us-central2
```

Crie uma VM do Compute Engine para fazer o download e o pré-processamento do conjunto de dados. Para mais informações, consulte Criar e iniciar uma instância do Compute Engine.

$ gcloud compute instances create vm-name \
    --zone=us-central2-b \
    --image-family=ubuntu-2204-lts \
    --image-project=ubuntu-os-cloud \
    --machine-type=n1-standard-16 \
    --boot-disk-size=300GB

Conecte-se à VM do Compute Engine usando SSH:
```
$ gcloud compute ssh vm-name --zone=us-central2-b
```
Quando você se conecta à VM, o prompt do shell muda de username@projectname para username@vm-name.
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 update && \
  sudo apt-get install python3-pip && \
  sudo apt-get install -y python3-tk && \
  pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow numpy absl-py tensorflow && \
  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 arquivos TFRecord (*.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. Ela gera arquivos *.tfrecord no diretório de dados local. O script de download e conversão do COCO leva aproximadamente uma hora para ser concluído.
Copie os dados para o bucket do Cloud Storage.

Depois de converter os dados para o formato TFRecord, copie-os do armazenamento local para o bucket do Cloud Storage usando a CLI gcloud. Você deve copiar os arquivos de anotação. Eles ajudam a validar o desempenho do modelo.
```
(vm)$ gcloud storage cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gcloud storage cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```
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.

Exclua a VM do Compute Engine:

$ gcloud compute instances delete vm-name \
--zone=us-central2-b

Treinamento de dispositivo único do Cloud 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
```
Configure a Google Cloud CLI 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 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 formato a seguir:

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

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
```
Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento. O comando gcloud usado neste tutorial para configurar a TPU também configura permissões padrão para a conta de serviço do Cloud TPU configurada na etapa anterior. Caso queira permissões mais específicas, consulte as permissões de nível de acesso.

Configure e inicie a Cloud TPU

Use o comando gcloud para iniciar uma VM do Compute Engine e a Cloud TPU.
```
$ gcloud compute tpus tpu-vm create retinanet-tutorial \
--zone=europe-west4-a \
--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 da 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: se você tiver mais de um projeto, especifique o ID dele com a sinalização --project.

Para mais informações sobre o comando gcloud, consulte a referência da gcloud.

Observação: a primeira vez que você executar gcloud compute tpus em um projeto, ele levará cerca de cinco minutos para realizar tarefas de inicialização, como propagação de chave SSH e ativação da API.
Conecte-se à instância do Compute Engine usando SSH. Quando você está conectado à VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh retinanet-tutorial --zone=europe-west4-a
```
Importante: a partir desse ponto, o prefixo (vm) $ significa que é necessário executar o comando na instância de VM do Compute Engine.

Instalar pacotes extras

O aplicativo de treinamento do RetinaNet requer vários pacotes extras. Instale-os agora:

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

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
```

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

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/retinanet-train
(vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"

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/legacy/detection

Treinamento sobre dispositivos de Cloud TPU único

Os scripts de treinamento a seguir foram executados em uma Cloud TPU v3-8. Ela isso levará mais tempo, mas também é possível executá-los em um Cloud TPU v2-8.

O exemplo de script a seguir treina apenas 10 etapas e leva menos de 5 minutos para execução em uma TPU v3-8. O treinamento para a conversão leva cerca de 22.500 etapas e aproximadamente 1 hora e meia em uma TPU v3-8 do Cloud TPU.

Configure as seguintes variáveis de ambiente:

(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

Execute o script de treinamento:
```
(vm)$ python3 main.py \
     --strategy_type=tpu \
     --tpu=${TPU_NAME} \
     --model_dir=${MODEL_DIR} \
     --mode="train" \
     --params_override="{ type: retinanet, train: { total_steps: 10, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet50/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: 5000 } }"
```
Descrições de sinalizações de comando

strategy_type

Para treinar o modelo RetinaNet em uma TPU, defina o distribution_strategy como tpu.

tpu

O nome da Cloud TPU. Isso é definido usando a variável de ambiente TPU_NAME.

model_dir

O bucket do Cloud Storage em que os checkpoints e os resumos são armazenados durante o treinamento. Use uma pasta atual para carregar os checkpoints criados anteriormente em uma TPU com o mesmo tamanho e versão do TensorFlow.

mode

Defina como train para treinar o modelo ou eval para avaliar o modelo.

params_override

Uma string JSON que modifica parâmetros de script padrão. Para mais informações sobre parâmetros de script, consulte /usr/share/models/official/legacy/detection/main.py.

O modelo será treinado para dez etapas em cerca de cinco minutos em uma TPU v3-8. Quando o for concluído, você verá uma saída semelhante a esta:

Train Step: 10/10  / loss = {
  'total_loss': 2.4581615924835205,
  'cls_loss': 1.4098565578460693,
  'box_loss': 0.012001709081232548,
  'model_loss': 2.0099422931671143,
  'l2_regularization_loss': 0.44821977615356445,
  'learning_rate': 0.008165999
}
/ training metric = {
  'total_loss': 2.4581615924835205,
  'cls_loss': 1.4098565578460693,
  'box_loss': 0.012001709081232548,
  'model_loss': 2.0099422931671143,
  'l2_regularization_loss': 0.44821977615356445,
 'learning_rate': 0.008165999
}

Avaliação de dispositivos de Cloud TPU único

O procedimento a seguir usa os dados de avaliação do COCO. A execução das etapas de avaliação em uma TPU v3-8 leva cerca de 10 minutos.

Configure as seguintes variáveis de ambiente:
```
(vm)$ export EVAL_SAMPLES=5000
```

Execute o script de avaliação:

(vm)$ python3 main.py \
      --strategy_type=tpu \
      --tpu=${TPU_NAME} \
      --model_dir=${MODEL_DIR} \
      --checkpoint_path=${MODEL_DIR} \
      --mode=eval_once \
      --params_override="{ type: retinanet, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: ${EVAL_SAMPLES} } }"

Descrições de sinalizações de comando

strategy_type: A estratégia de distribuição a ser usada. tpu ou multi_worker_gpu.
tpu: O nome da Cloud TPU. Isso é definido usando a variável de ambiente TPU_NAME.
model_dir: O bucket do Cloud Storage em que os checkpoints e os resumos são armazenados durante o treinamento. É possível usar uma pasta existente para carregar checkpoints gerados que foram criados em uma TPU do mesmo tamanho para a versão anterior.
mode: Um de train, eval ou train_and_eval.
params_override: Uma string JSON que modifica parâmetros de script padrão. Para mais informações sobre parâmetros de script, consulte /usr/share/models/official/legacy/detection/main.py.

No final da avaliação, você verá mensagens semelhantes às seguintes no console:

Accumulating evaluation results...
DONE (t=7.66s).
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000

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

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

zone

A zona em que o Cloud TPU reside.

Escalone seu modelo com os pods da Cloud TPU

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

Como treinar Retinanet em um 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
```
Configure a Google Cloud CLI 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 de baixo. da página para permitir que gcloud faça chamadas de API do Google Cloud com sua credenciais do Google Cloud.
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 formato a seguir:
```
service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
```
Crie um bucket do Cloud Storage usando o comando a seguir ou use um bucket criado anteriormente para o projeto.

Importante: configure os recursos do Cloud TPU e o bucket do Cloud Storage na mesma região e zona para reduzir a latência e os custos da rede. As Cloud TPUs estão localizadas zonas específicas, que são subdivisões dentro de uma região.

No comando a seguir, substitua europe-west4 pelo nome da região que você vai usar para executar o treinamento. Substitua bucket-name pelo nome que você quer atribuir ao bucket.
```
gcloud storage buckets create gs://bucket-name \
  --project=${PROJECT_ID} \
  --location=europe-west4
```
Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento. O comando gcloud usado neste tutorial configura permissões padrão para a conta de serviço do Cloud TPU configurada na etapa anterior. Se quiser permissões mais específicas, consulte permissões de nível de acesso.

O local do bucket precisa estar na mesma região que os recursos da TPU.
Se você já preparou o conjunto de dados COCO e o moveu para o armazenamento no bucket, é possível usá-lo novamente para o treinamento de pods. Se você ainda não preparou o conjunto de dados COCO, prepare-o agora e volte aqui para configurar o treinamento.
Configurar e iniciar 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 para criar o pod do TPU, você poderá colocar sua solicitação na fila usando recursos em fila. Os recursos em fila permitem que você receba capacidade assim que ela estiver disponível. Para solicitar os recursos do Cloud TPU como recursos enfileirados, use o comando gcloud compute tpus queued-resources create. Para mais informações, consulte Gerenciar recursos em fila.

Inicie um pod de VM de TPU usando o comando gcloud compute tpus tpu-vm. Neste tutorial, especificamos um pod v3-32. Para outras opções de pod, consulte a página de tipos de TPU disponíveis.
```
$ gcloud compute tpus tpu-vm create retinanet-tutorial \
  --zone=europe-west4-a \
  --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 da 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.
Conecte-se à instância de VM da TPU usando SSH. Quando você está conectado à VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh retinanet-tutorial --zone=europe-west4-a
```
Importante: a partir deste ponto, o prefixo (vm) $ significa que você precisa e executar o comando na instância da VM do Compute Engine. começa com (vm)$ na janela de sessão da VM.

Defina a variável de nome da Cloud TPU.

(vm)$ export TPU_NAME=retinanet-tutorial

Definir variáveis de bucket do Cloud Storage

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}/retinanet-train
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```
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.

Instalar pacotes extras

O aplicativo de treinamento do RetinaNet requer vários pacotes extras. Instalar com eles agora:

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

Instale os requisitos do TensorFlow.

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

Defina algumas variáveis de ambiente obrigatórias:

(vm)$ export RESNET_PRETRAIN_DIR=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
(vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"
(vm)$ export TPU_LOAD_LIBRARY=0

Mude para o diretório que armazena o modelo:

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

Treine o modelo
```
(vm)$ python3 main.py \
  --strategy_type=tpu \
  --tpu=${TPU_NAME} \
  --model_dir=${MODEL_DIR} \
  --mode=train \
  --model=retinanet \
  --params_override="{architecture: {use_bfloat16: true}, eval: {batch_size: 40, eval_file_pattern: ${EVAL_FILE_PATTERN}, val_json_file: ${VAL_JSON_FILE}}, postprocess: {pre_nms_num_boxes: 1000}, predict: {batch_size: 40}, train: {batch_size: 256, checkpoint: {path: ${RESNET_PRETRAIN_DIR}, prefix: resnet50/}, iterations_per_loop: 5000, total_steps: 5625, train_file_pattern: ${TRAIN_FILE_PATTERN}, } }" 
```
Descrições de sinalizações de comando

tpu

O nome da TPU.

model_dir

Especifica o diretório em que os checkpoints 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://...). É possível reutilizar uma pasta existente para carregar os dados do checkpoint atual e armazenar pontos de verificação adicionais desde que os anteriores tenham sido criados usando um Cloud TPU do mesmo tamanho e versão do TensorFlow.

params_override

Uma string JSON que modifica parâmetros de script padrão. Para mais informações sobre parâmetros de script, consulte /usr/share/tpu/models/official/legacy/detection/main.py.

Este procedimento treina o modelo no conjunto de dados COCO para treinamento 5625 etapas. O treinamento leva aproximadamente 20 minutos em uma TPU v3-32. Quando Quando o treinamento for concluído, uma mensagem semelhante a esta será exibida:

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

   Train Step: 5625/5625  / loss = {'total_loss': 0.730501651763916,
   'cls_loss': 0.3229793608188629, 'box_loss': 0.003082591574639082,
   'model_loss': 0.4771089553833008, 'l2_regularization_loss': 0.2533927261829376,
   'learning_rate': 0.08} / training metric = {'total_loss': 0.730501651763916,
   'cls_loss': 0.3229793608188629, 'box_loss': 0.003082591574639082,
   'model_loss': 0.4771089553833008, 'l2_regularization_loss': 0.2533927261829376,
   'learning_rate': 0.08}

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.

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.

Exclua os recursos do Cloud TPU e do Compute Engine.

$ gcloud compute tpus tpu-vm delete retinanet-tutorial \
  --zone=europe-west4-a

Execute gcloud compute tpus tpu-vm list para verificar se os recursos foram excluídos. A exclusão pode levar vários minutos. Uma resposta como esta indica que suas instâncias foram excluídas com sucesso.
```
$ gcloud compute tpus tpu-vm list --zone=europe-west4-a
```
```
Listed 0 items.
```
Exclua o bucket do Cloud Storage. Substitua bucket-name pelo nome do bucket do Cloud Storage.
Exclua o bucket do Cloud Storage usando a CLI gcloud, conforme mostrado no exemplo a seguir. Substitua bucket-name pelo nome do bucket do Cloud Storage.
```
$ 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 um conjunto de dados disponível publicamente ou no seu próprio conjunto de dados. Modelos do TensorFlow treinados em Cloud TPUs geralmente exigem que os conjuntos de dados estejam 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 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. 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 e Ajustar hiperparâmetros.

Inferência

Depois de treinar o modelo, é possível usá-lo para inferência (também chamada de previsão). Você pode usar a ferramenta de conversão de inferência da Cloud TPU para preparar e otimizar um modelo do TensorFlow para inferência na Cloud TPU v5e. Para mais informações sobre a inferência no Cloud TPU v5e, consulte Introdução à inferência do Cloud TPU v5e.

Treinar com diferentes tamanhos de imagem

Use uma rede de backbone maior (por exemplo, ResNet-101) do ResNet-50). Uma imagem de entrada maior e um backbone mais eficiente produzirão um um modelo mais lento, mas mais preciso.

Usar uma base diferente

Como alternativa, é possível pré-treinar um modelo ResNet no seu próprio conjunto de dados e usá-lo como base para seu modelo do RetinaNet. Com um pouco mais de trabalho, você vai também trocar uma rede de backbone pelo ResNet. Por fim: se estiver interessado em implementar seus próprios modelos de detecção de objetos, este em nuvem pode ser uma boa base para mais experimentos.