Esta página foi traduzida pela API Cloud Translation.

Como treinar o ShapeMask no Cloud TPU (TF 2.x)

Neste documento, você verá como executar o modelo ShapeMask usando a Cloud TPU com o conjunto de dados COCO.

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

Make sure that billing is enabled for your Google Cloud project.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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.

Treinamento de dispositivo único do Cloud TPU

Nesta seção, você vai encontrar informações sobre como configurar recursos do Cloud Storage, da VM e do Cloud TPU para treinamento em dispositivos únicos.

Se você planeja treinar em uma fração do pod da TPU, consulte Treinamento em pods de TPU para entender as mudanças necessárias para treinar em frações de pod.

No Cloud Shell, crie uma variável para o ID.
```
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 do Google Cloud.

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

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.

O local do bucket precisa estar na mesma região que sua máquina virtual (VM) e nó de 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.

O bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento. A ferramenta gcloud compute tpus tpu-vm usada neste tutorial configura permissões padrão para a conta de serviço da Cloud TPU que você configurou no etapa anterior. Caso queira permissões mais específicas, consulte as permissões de nível de acesso.

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, é possível iniciar os recursos da TPU e preparar o Cloud TPU para o treinamento. Caso contrário, siga as etapas abaixo para preparar o conjunto de dados.

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

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. Ele gera arquivos *.tfrecord no diretório de dados locais. 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 dados 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}
```
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

Iniciar os recursos da TPU e treinar o modelo

Use o comando gcloud para iniciar os recursos da TPU.
```
$ gcloud compute tpus tpu-vm create shapemask-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ê estiver conectado para a VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh shapemask-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.

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 do bucket de armazenamento. Substitua bucket-name pelo nome do seu bucket de armazenamento:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
Defina a variável de nome da Cloud TPU.
```
(vm)$ export TPU_NAME=local
```

Defina a variável de ambiente PYTHONPATH:

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

Mude para o diretório que armazena o modelo:

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

Adicione algumas variáveis de ambiente obrigató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 SHAPE_PRIOR_PATH=gs://cloud-tpu-checkpoints/shapemask/kmeans_class_priors_91x20x32x32.npy
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/shapemask

Ao criar a 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 do PJRT:
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```

Treine o modelo ShapeMask:

O script a seguir executa um treinamento de amostra que é treinado por apenas 100 etapas e leva aproximadamente 10 minutos para ser concluído em uma TPU v3-8. O treinamento para a conversão leva cerca de 22.500 etapas e aproximadamente 6 horas em uma TPU v3-8.

(vm)$ python3 main.py \
  --strategy_type=tpu \
  --tpu=${TPU_NAME} \
  --model_dir=${MODEL_DIR} \
  --mode=train \
  --model=shapemask \
  --params_override="{train: {total_steps: 100, learning_rate: {init_learning_rate: 0.08, learning_rate_levels: [0.008, 0.0008], learning_rate_steps: [15000, 20000], }, checkpoint: { path: ${RESNET_CHECKPOINT},prefix: resnet50}, train_file_pattern: ${TRAIN_FILE_PATTERN}}, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}}, shapemask_parser: {output_size: [640, 640]}}"

Descrições de sinalizações de comando

strategy_type: Para treinar o modelo Shapemask em uma TPU, é necessário definir o distribution_strategy como tpu.
tpu: O nome da Cloud TPU. Isso é definido usando o método TPU_NAME.
model_dir: O diretório em que os pontos de controle 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 existente para carregar dados do ponto de controle atual e armazenar outros pontos, contanto que os anteriores tenham sido criados usando a 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.

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

Train Step: 100/100  / loss = {'total_loss': 10.815635681152344,
'loss': 10.815635681152344, 'retinanet_cls_loss': 1.4915691614151,
'l2_regularization_loss': 4.483549118041992,
'retinanet_box_loss': 0.013074751943349838,
'shapemask_prior_loss': 0.17314358055591583,
'shapemask_coarse_mask_loss': 1.953366756439209,
'shapemask_fine_mask_loss': 2.216097831726074, 'model_loss': 6.332086086273193,
'learning_rate': 0.021359999} / training metric = {'total_loss': 10.815635681152344,
'loss': 10.815635681152344, 'retinanet_cls_loss': 1.4915691614151,
'l2_regularization_loss': 4.483549118041992,
'retinanet_box_loss': 0.013074751943349838,
'shapemask_prior_loss': 0.17314358055591583,
'shapemask_coarse_mask_loss': 1.953366756439209,
'shapemask_fine_mask_loss': 2.216097831726074,
'model_loss': 6.332086086273193, 'learning_rate': 0.021359999}

Execute o script para avaliar o modelo ShapeMask. Isso leva cerca de 10 minutos em uma TPU v3-8:

(vm)$ python3 main.py \
--strategy_type=tpu \
--tpu=${TPU_NAME} \
--model_dir=${MODEL_DIR} \
--checkpoint_path=${MODEL_DIR} \
--mode=eval_once \
--model=shapemask \
--params_override="{eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: 5000 }, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}}, shapemask_parser: {output_size: [640, 640]}}"

Descrições de sinalizações de comando

strategy_type: Para treinar o modelo Shapemask em uma TPU, é preciso definir a distribution_strategy para tpu.
tpu: O nome da Cloud TPU. Isso é definido usando a variável de ambiente TPU_NAME.
model_dir: O diretório em que os checkpoints e resumos são armazenados durante o modelo treinamento. 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 de checkpoint atuais e armazenar outros checkpoints, contanto que os anteriores tenham sido criados usando uma Cloud TPU do 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.

Quando a avaliação for concluída, será exibida uma mensagem semelhante à seguinte:

DONE (t=5.47s).
 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 etapas a seguir 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 shapemask-tutorial \
    --zone=europe-west4-a
```
Descrições de sinalizações de comando

zone

A zona em que o Cloud TPU residia.

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

Escalone seu 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 sua 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 Google Cloud serviços.
```
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 existente.

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. Os Cloud TPUs estão localizados em zonas específicas, que são subdivisões dentro de uma região.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
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 do pod.
Inicie um pod do Cloud TPU

Neste tutorial, especificamos um pod v3-32. Para outras opções de pod, 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 shapemask-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 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, vai levar cerca de 5 minutos para executar tarefas de inicialização, como propagação de chave SSH e ativação de API.
Observação: se você tiver mais de um projeto, especifique o ID do projeto com a sinalização --project.
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 shapemask-tutorial --zone=europe-west4-a
```
Importante: a partir deste ponto, o prefixo (vm) $ significa que você precisa 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

Configure as seguintes variáveis de ambiente, substituindo bucket-name pelo nome do bucket do Cloud Storage:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
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.

Atualize as variáveis de treinamento necessárias.

(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/shapemask-pods
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(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
(vm)$ export SHAPE_PRIOR_PATH=gs://cloud-tpu-checkpoints/shapemask/kmeans_class_priors_91x20x32x32.npy

Defina algumas variáveis de ambiente obrigatórias:

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

Inicie o treinamento do pod.

O treinamento de exemplo é executado por 20 etapas e leva aproximadamente 10 minutos para ser concluído em um nó de TPU v3-32. O treinamento para convergência leva cerca de 11.250 e aproximadamente 2 horas em um Pod de TPU v3-32.
```
(vm)$ python3 main.py \
 --strategy_type=tpu \
 --tpu=${TPU_NAME} \
 --model_dir=${MODEL_DIR} \
 --mode=train \
 --model=shapemask \
 --params_override="{train: { batch_size: 128, iterations_per_loop: 500, total_steps: 20, learning_rate: {'learning_rate_levels': [0.008, 0.0008], 'learning_rate_steps': [10000, 13000] }, 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}}, shapemask_head: {use_category_for_mask: true, shape_prior_path: ${SHAPE_PRIOR_PATH}} }"
```
Descrições de sinalizações de comando

strategy_type

Para treinar o modelo Shapemask em uma TPU, é preciso definir a distribution_strategy para tpu.

tpu

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

model_dir

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á uma. Ao usar um Cloud TPU, o model_dir precisa ser um caminho do Cloud Storage (gs://...). É possível reutilizar uma pasta atual para carregar dados de checkpoint atuais e armazenar outros checkpoints, contanto que os anteriores tenham sido criados usando um Cloud TPU do 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.

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.

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.

Exclua os recursos do Cloud TPU e do Compute Engine.

$ gcloud compute tpus tpu-vm delete shapemask-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. A saída do comando a seguir não pode incluir nenhum dos recursos de TPU criados neste tutorial:
```
$ gcloud compute tpus tpu-vm list --zone=europe-west4-a
```
Execute a CLI gcloud conforme mostrado, substituindo bucket-name por o nome do bucket do Cloud Storage criado para este tutorial:

Atenção: todos os dados de treinamento serão perdidos ao excluir o bucket. Por isso, siga essa etapa apenas quando terminar o tutorial.
```
$ gcloud storage rm gs://bucket-name --recursive
```

A seguir

Treinar com diferentes tamanhos de imagem

Para explorar, use uma rede neural maior. Por exemplo, ResNet-101 em vez de ResNet-50. Uma imagem maior de entrada e uma rede neural mais potente vão produzir um modelo mais lento, porém, mais preciso.

Usar uma base diferente

Se preferir, faça o pré-treinamento de um modelo do ResNet no seu próprio conjunto de dados e use-o como base para o modelo do ShapeMask. Com um pouco mais de trabalho, também é possível trocar em uma rede neural alternativa no lugar do ResNet. Por fim, se você têm interesse em implementar seus próprios modelos de detecção de objetos, essa rede pode ser uma boa base para mais experimentos.