Questa pagina è stata tradotta dall'API Cloud Translation.

Addestramento di ShapeMask su Cloud TPU (TF 2.x)

Questo documento mostra come eseguire il modello ShapeMask utilizzando Cloud TPU con il set di dati COCO.

Le istruzioni riportate di seguito presuppongono che tu abbia già familiarità con l'esecuzione di un modello con Cloud TPU. Se non hai mai utilizzato Cloud TPU, puoi consulta la Guida rapida per un'introduzione di base.

Se prevedi di eseguire l'addestramento su una sezione di pod di TPU, consulta Addestramento sui pod TPU per comprendere le modifiche dei parametri necessarie per le sezioni di pod.

Obiettivi

Prepara il set di dati COCO
Crea un bucket Cloud Storage per conservare il set di dati e l'output del modello
Configurazione delle risorse TPU per l'addestramento e la valutazione
Esegui addestramento e valutazione su una singola Cloud TPU o un singolo pod di Cloud TPU

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Compute Engine
Cloud TPU
Cloud Storage

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

Prima di iniziare questo tutorial, verifica che il tuo progetto Google Cloud sia corretto configurazione.

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

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Questa procedura dettagliata utilizza i componenti fatturabili di Google Cloud. Controlla il Pagina dei prezzi di Cloud TPU per stimare i costi. Assicurati di pulire che crei una volta terminato per evitare inutili addebiti.

Addestramento su dispositivo singolo Cloud TPU

Questa sezione fornisce informazioni sulla configurazione di Cloud Storage, VM Risorse Cloud TPU per l'addestramento di dispositivi singoli.

Se prevedi di eseguire l'addestramento su una sezione di pod di TPU, consulta Addestramento sui pod TPU per comprendere le modifiche necessarie per l'addestramento sulle sezioni di pod.

In Cloud Shell, crea una variabile per il ID.
```
export PROJECT_ID=project-id
```
Configura Google Cloud CLI per utilizzare il progetto in cui vuoi creare con Cloud TPU.
```
gcloud config set project ${PROJECT_ID}
```
La prima volta che esegui questo comando in una nuova VM Cloud Shell, Pagina Authorize Cloud Shell visualizzata. Fai clic su Authorize in basso della pagina per consentire a gcloud di effettuare chiamate API Google Cloud con il tuo le credenziali di Google Cloud.

Creare un account di servizio per il progetto Cloud TPU.

gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID

Il comando restituisce un account di servizio Cloud TPU con il seguente formato:

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

Prepara il set di dati COCO

Questo tutorial utilizza il set di dati COCO. Il set di dati deve essere in formato TFRecord su un bucket Cloud Storage da usare per l'addestramento.

La località del bucket deve trovarsi nella stessa regione della macchina virtuale (VM) e il nodo TPU. Le VM e i nodi TPU si trovano in zone specifiche, che sono suddivisioni all'interno di una regione.

Il bucket Cloud Storage archivia i dati che utilizzi per addestrare il modello i risultati dell'addestramento. Lo strumento gcloud compute tpus execution-groups utilizzato in questo tutorial configura le autorizzazioni predefinite per l'account di servizio Cloud TPU passaggio precedente. Se vuoi autorizzazioni più granulari, consulta le autorizzazioni a livello di accesso.

Se hai già preparato il set di dati COCO su un bucket Cloud Storage si trova nella zona che utilizzerai per addestrare il modello, puoi avviare le risorse TPU per preparare Cloud TPU per l'addestramento. In caso contrario, segui questi passaggi per prepararti del set di dati.

In Cloud Shell, configura gcloud con il tuo progetto ID.

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

In Cloud Shell, crea un bucket Cloud Storage utilizzando il comando seguente:

Nota: nel seguente comando, sostituisci bucket-name con il nome che vuoi assegnare al bucket.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
Avvia un'istanza VM di Compute Engine.

Questa istanza VM verrà utilizzata solo per scaricare e pre-elaborare il COCO del set di dati. Compila il campo instance-name con un nome a tua scelta.
```
$ 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
```
Descrizioni flag di comando

vm-only

Crea solo una VM. Per impostazione predefinita, il comando gcloud compute tpus execution-groups crea una VM e una Cloud TPU.

name

Il nome della Cloud TPU da creare.

zone

La zona in cui prevedi di creare la tua Cloud TPU.

disk-size

La dimensione del disco rigido in GB della VM creata dal gcloud compute tpus execution-groups .

machine-type

Il tipo di macchina della VM di Compute Engine.

tf-version

La versione di Tensorflow gcloud compute tpus execution-groups viene installata sulla VM.
Se non hai eseguito automaticamente l'accesso all'istanza Compute Engine, esegui questo comando ssh per accedere. Dopo aver eseguito l'accesso alla VM, il prompt della shell cambia da Da username@projectname a username@vm-name:
```
  $ gcloud compute ssh instance-name --zone=europe-west4-a
  
```
Configura due variabili, una per il bucket di archiviazione creati in precedenza e una per la directory che contiene i dati di addestramento (DATA_DIR) nel bucket di archiviazione.
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```

Installa i pacchetti necessari per pre-elaborare i dati.

(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"

Esegui lo script download_and_preprocess_coco.sh per convertire il set di dati COCO in un set di TFRecord (*.tfrecord) che l'addestramento come previsto dall'applicazione.
```
(vm)$ git clone https://github.com/tensorflow/tpu.git
(vm)$ sudo bash tpu/tools/datasets/download_and_preprocess_coco.sh ./data/dir/coco
```
Questa operazione installa le librerie richieste, quindi esegue la pre-elaborazione lo script. Restituisce una serie di file *.tfrecord nella directory dei dati locali. Il download e lo script di conversione del COCO richiede circa un'ora.
Copia i dati nel bucket Cloud Storage

Dopo aver convertito i dati in TFRecord, copiali dallo spazio di archiviazione locale al bucket Cloud Storage con gcloud CLI. Devi e copiare anche i file di annotazioni. Questi file consentono di convalidare le prestazioni dei dispositivi.
```
(vm)$ gcloud storage cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gcloud storage cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```
Esegui la pulizia delle risorse VM

Una volta che il set di dati COCO è stato convertito in TFRecord e copiato DATA_DIR sul tuo bucket Cloud Storage, puoi eliminare di Compute Engine.

Disconnettiti dall'istanza Compute Engine:
```
(vm)$ exit
```
Il tuo prompt ora dovrebbe essere username@projectname, a indicare che ti trovi in in Cloud Shell.

Elimina l'istanza di Compute Engine.

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

Avvia le risorse TPU e addestra il modello

Utilizza il comando gcloud per avviare le risorse 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
```
Descrizioni flag di comando

zone

La zona in cui prevedi di creare la tua Cloud TPU.

accelerator-type

Il tipo di acceleratore specifica la versione e le dimensioni della Cloud TPU che vuoi creare. Per ulteriori informazioni sui tipi di acceleratori supportati per ogni versione di TPU, vedi Versioni TPU.

version

La versione software di Cloud TPU.

Nota: se hai più di un progetto, devi specificare l'ID progetto con la bandiera --project.

Per ulteriori informazioni sul comando gcloud, consulta la documentazione di riferimento di gcloud.

Nota: la prima volta che esegui gcloud compute tpus su un progetto, ci vuole circa 5 minuti per eseguire attività di avvio, come la propagazione delle chiavi SSH e attivazione delle API.
Connettiti all'istanza Compute Engine tramite SSH. Quando la connessione è attiva alla VM, il prompt della shell passa da username@projectname a username@vm-name:
```
gcloud compute tpus tpu-vm ssh shapemask-tutorial --zone=europe-west4-a
```
Punto chiave: da questo momento in poi, il prefisso (vm) $ significa che dovresti eseguire il comando sull'istanza VM di Compute Engine.

Installa i requisiti di TensorFlow.

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

Lo script di addestramento richiede un pacchetto aggiuntivo. Installalo ora:
```
(vm)$ pip3 install --user tensorflow-model-optimization>=0.1.3
```
Imposta la variabile del nome del bucket di archiviazione. Sostituisci bucket-name con il nome del tuo bucket di archiviazione:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
Imposta la variabile nome Cloud TPU.
```
(vm)$ export TPU_NAME=local
```

Imposta la variabile di ambiente PYTHONPATH:

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

Passa alla directory in cui è archiviato il modello:

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

Aggiungi alcune variabili di ambiente obbligatorie:

(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

Durante la creazione della TPU, se imposti il parametro --version su una versione che termina con -pjrt, imposta le seguenti variabili di ambiente per abilitare il runtime PJRT:
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```
Addestra il modello ShapeMask:

Lo script seguente esegue un addestramento di esempio per soli 100 passaggi e il completamento richiede circa 10 minuti su una TPU v3-8. Per eseguire l'addestramento la convergenza richiede circa 22.500 passi e circa 6 ore su una 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]}}"
```
Descrizioni flag di comando

strategy_type

Per addestrare il modello Shapemask su una TPU, devi impostare il valore distribution_strategy a tpu.

tpu

Il nome della Cloud TPU. Viene impostato utilizzando il parametro TPU_NAME variabile di ambiente.

model_dir

La directory in cui sono archiviati i checkpoint e i riepiloghi durante durante l'addestramento del modello. Se la cartella non è presente, il programma ne crea una. Quando utilizzi una Cloud TPU, model_dir deve essere un percorso Cloud Storage (gs://...). Puoi riutilizzare una cartella esistente per caricare i dati dei checkpoint attuali e archiviare checkpoint aggiuntivi, purché i precedenti checkpoint siano creato utilizzando una Cloud TPU delle stesse dimensioni e TensorFlow completamente gestita.

mode

Impostalo su train per addestrare il modello o su eval per valutare il modello.

params_override

Una stringa JSON che sostituisce i parametri di script predefiniti. Per ulteriori informazioni informazioni sui parametri di script, consulta /usr/share/models/official/legacy/detection/main.py.

Al termine dell'addestramento, viene visualizzato un messaggio simile al seguente:
```
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}
```

Esegui lo script per valutare il modello ShapeMask. L'operazione richiede circa 10 minuti su una 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]}}"

Descrizioni flag di comando

strategy_type: Per addestrare il modello Shapemask su una TPU, devi impostare il valore distribution_strategy a tpu.
tpu: Il nome della Cloud TPU. Viene impostato utilizzando il parametro TPU_NAME variabile di ambiente.
model_dir: La directory in cui sono archiviati i checkpoint e i riassunti durante il modello addestramento. Se la cartella non è presente, il programma ne crea una. Se utilizzi un Cloud TPU, model_dir deve essere un Percorso Cloud Storage (gs://...). Puoi riutilizzare cartella esistente per caricare i dati dei checkpoint attuali e archiviare altre i checkpoint purché i checkpoint precedenti siano stati creati utilizzando un Cloud TPU delle stesse dimensioni e versione TensorFlow.
mode: Impostalo su train per addestrare il modello o su eval per valutare il modello.
params_override: Una stringa JSON che sostituisce i parametri di script predefiniti. Per ulteriori informazioni informazioni sui parametri di script, consulta /usr/share/models/official/legacy/detection/main.py.

Al termine della valutazione, viene visualizzato un messaggio simile al seguente:

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

Hai completato l'addestramento e la valutazione su un singolo dispositivo. Utilizza la i seguenti passaggi per eliminare le risorse TPU su singolo dispositivo attuali.

Disconnettiti dall'istanza Compute Engine:
```
(vm)$ exit
```
Il tuo prompt ora dovrebbe essere username@projectname, a indicare che ti trovi in in Cloud Shell.
Elimina la risorsa TPU.
```
$ gcloud compute tpus tpu-vm delete shapemask-tutorial \
    --zone=europe-west4-a
```
Descrizioni flag di comando

zone

La zona in cui Cloud TPU ha risieduto.

A questo punto, puoi concludere questo tutorial e ripulire, oppure continuare ed esplorare l'esecuzione del modello sui pod di Cloud TPU.

Scala il tuo modello con i pod di Cloud TPU

L'addestramento del modello sui pod di Cloud TPU potrebbe richiedere alcune modifiche allo script di addestramento. Per informazioni, consulta Addestramento sui pod TPU.

Addestramento dei pod di TPU

Apri una finestra di Cloud Shell.

Apri Cloud Shell
Crea una variabile per l'ID del progetto.
```
export PROJECT_ID=project-id
```
Configura Google Cloud CLI per utilizzare il progetto in cui vuoi creare con Cloud TPU.
```
gcloud config set project ${PROJECT_ID}
```
La prima volta che esegui questo comando in una nuova VM Cloud Shell, Pagina Authorize Cloud Shell visualizzata. Fai clic su Authorize in basso della pagina per consentire a gcloud di effettuare chiamate API Google Cloud con il tuo e credenziali.
Creare un account di servizio per il progetto Cloud TPU.

Gli account di servizio consentono al servizio Cloud TPU di accedere ad altri servizi Google Cloud i servizi di machine learning.
```
gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID
```
Il comando restituisce un account di servizio Cloud TPU con il seguente formato:
```
service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
```
Crea un bucket Cloud Storage utilizzando il comando seguente oppure utilizza un bucket esistente.

Importante: configura le risorse Cloud TPU e il tuo bucket Cloud Storage nella stessa regione e zona per ridurre latenza di rete e costi di rete. Le Cloud TPU si trovano in zone specifiche, che sono suddivisioni all'interno di una regione.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
Se in precedenza hai preparato il set di dati COCO e lo hai spostato nel tuo spazio di archiviazione di archiviazione, puoi utilizzarlo di nuovo per l'addestramento dei pod. Se non hai ancora preparato il set di dati COCO, preparalo ora e torna qui per configurarlo durante l'addestramento del pod.
avvia un pod di Cloud TPU

Questo tutorial specifica un pod v3-32. Per altre opzioni di pod, consulta Versioni TPU.

Nota:se al momento non è disponibile una capacità sufficiente per creare il pod di TPU, puoi accoda la richiesta utilizzando risorse in coda. Le risorse in coda ti consentono di ricevere capacità una volta la disponibilità del servizio. Per richiedere le risorse Cloud TPU come risorse in coda, utilizza il comando gcloud compute tpus queued-resources create. Per ulteriori informazioni, vedi Gestione delle risorse in coda.
```
$ 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
```
Descrizioni flag di comando

zone

La zona in cui prevedi di creare la tua Cloud TPU.

accelerator-type

Il tipo di acceleratore specifica la versione e le dimensioni della Cloud TPU che vuoi creare. Per ulteriori informazioni sui tipi di acceleratori supportati per ogni versione di TPU, vedi Versioni TPU.

version

La versione software di Cloud TPU.

Nota: la prima volta che esegui gcloud su un progetto, sono necessari circa cinque minuti per eseguire attività di avvio come la propagazione delle chiavi SSH e l'attivazione delle API.
Nota: se hai più di un progetto, devi specificare l'ID progetto con il flag --project.
Connettiti all'istanza Compute Engine tramite SSH. Quando la connessione è attiva alla VM, il prompt della shell passa da username@projectname a username@vm-name:
```
gcloud compute tpus tpu-vm ssh shapemask-tutorial --zone=europe-west4-a
```
Punto chiave: da questo momento in poi, il prefisso (vm) $ significa che il comando sull'istanza VM di Compute Engine.

Installa i requisiti di TensorFlow.

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

Lo script di addestramento richiede un pacchetto aggiuntivo. Installalo ora:
```
(vm)$ pip3 install --user tensorflow-model-optimization>=0.1.3
```
Configura le seguenti variabili di ambiente, sostituendo bucket-name con il nome del tuo bucket Cloud Storage:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
L'applicazione di addestramento richiede che i dati di addestramento siano accessibili di archiviazione ideale in Cloud Storage. L'applicazione di addestramento utilizza anche il tuo Cloud Storage per archiviare i checkpoint durante l'addestramento.

Aggiorna le variabili di addestramento richieste.

(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

Imposta alcune variabili di ambiente obbligatorie:

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

Passa alla directory in cui è archiviato il modello:

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

Avvia l'addestramento del pod.

L'addestramento di esempio viene eseguito per 20 passaggi e richiede circa 10 minuti su un nodo TPU v3-32. Per l'addestramento alla convergenza servono circa 11.250 passaggi e circa 2 ore su un pod di 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}} }"
```
Descrizioni flag di comando

strategy_type

Per addestrare il modello Shapemask su una TPU, devi impostare il valore distribution_strategy a tpu.

tpu

Il nome della Cloud TPU. Viene impostato utilizzando il parametro TPU_NAME variabile di ambiente.

model_dir

La directory in cui sono archiviati i checkpoint e i riepiloghi durante durante l'addestramento del modello. Se la cartella non è presente, il programma ne crea una. Quando utilizzando una Cloud TPU, model_dir deve essere un Percorso Cloud Storage (gs://...). Puoi riutilizzare cartella esistente per caricare i dati dei checkpoint attuali e archiviare altre i checkpoint purché i checkpoint precedenti siano stati creati utilizzando un Cloud TPU delle stesse dimensioni e versione TensorFlow.

mode

Impostalo su train per addestrare il modello o su eval per valutare il modello.

params_override

Una stringa JSON che sostituisce i parametri di script predefiniti. Per ulteriori informazioni informazioni sui parametri di script, consulta /usr/share/models/official/legacy/detection/main.py.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Disconnettiti dall'istanza Compute Engine, se non l'hai già fatto. Fatto:
```
(vm)$ exit
```
Il tuo prompt ora dovrebbe essere username@projectname, a indicare che ti trovi in in Cloud Shell.

Elimina le tue risorse Cloud TPU e Compute Engine.

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

Verifica che le risorse siano state eliminate eseguendo gcloud compute tpus tpu-vm list. La l'eliminazione potrebbe richiedere diversi minuti. L'output del comando seguente non deve includere nessuna delle risorse TPU create in questo tutorial:
```
$ gcloud compute tpus tpu-vm list --zone=europe-west4-a
```
Esegui gcloud CLI come mostrato, sostituendo bucket-name con il nome del bucket Cloud Storage che hai creato per questo tutorial:

Attenzione: con l'eliminazione del bucket tutti i dati di addestramento andranno persi, esegui questo passaggio solo quando hai finito di eseguire il tutorial.
```
$ gcloud storage rm gs://bucket-name --recursive
```

Passaggi successivi

Esegui l'addestramento con immagini di dimensioni diverse

Puoi esplorare utilizzando una rete neurale più grande (ad esempio, ResNet-101 invece di ResNet-50). Un'immagine di input più grande e una rete neurale più potente produrre un modello più lento, ma più preciso.

Utilizza una base diversa

In alternativa, puoi esplorare il pre-addestramento di un modello ResNet sul tuo set di dati e come base per il tuo modello ShapeMask. Con un po' di lavoro extra, anche passare a una rete neurale alternativa al posto di ResNet. Infine, se ti interessa implementare i tuoi modelli di rilevamento degli oggetti, può essere una buona base per ulteriori esperimenti.