Questa pagina è stata tradotta dall'API Cloud Translation.

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

Questo documento descrive un'implementazione del modello di rilevamento degli oggetti RetinaNet. Il codice è disponibile su GitHub.

Le istruzioni riportate di seguito presuppongono che tu abbia già dimestichezza con l'esecuzione di un modello su 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 l'addestramento e la valutazione su un singolo Cloud TPU o un pod Cloud TPU

Costi

In questo documento utilizzi 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.

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.

Questa procedura dettagliata utilizza i componenti fatturabili di Google Cloud. Controlla il Pagina dei prezzi di Cloud TPU per stimare i costi.

Prepara il set di dati COCO

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

Se hai già preparato il set di dati COCO in un bucket Cloud Storage che si trova nella zona che utilizzerai per addestrare il modello, puoi andare direttamente all'addestramento su un singolo dispositivo. In caso contrario, segui questi passaggi per preparare il set di dati.

Apri una finestra di Cloud Shell.

Apri Cloud Shell

In Cloud Shell, configura gcloud con l'ID progetto.

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 comando seguente, sostituisci bucket-name con il nome che vuoi assegnare al bucket.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=us-central2
```

Crea una VM Compute Engine per scaricare e pre-elaborare il set di dati. Per maggiori informazioni le informazioni, vedi Crea e avvia un'istanza 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

Connettiti alla VM di Compute Engine tramite SSH:
```
$ gcloud compute ssh vm-name --zone=us-central2-b
```
Quando ti connetti alla VM, il prompt della shell cambia da username@projectname a username@vm-name.
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 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"

Esegui lo script download_and_preprocess_coco.sh per convertire il set di dati COCO in un set di file 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 *.tfrecord file 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 nel formato TFRecord, copiali dallo spazio di archiviazione locale nel bucket Cloud Storage utilizzando l'interfaccia a riga di comando gcloud. 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}
```
Disconnettiti dalla VM di Compute Engine:
```
(vm)$ exit
```
Il tuo prompt dovrebbe ora essere username@projectname, a indicare che ti trovi in Cloud Shell.

Elimina la VM di Compute Engine:

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

Addestramento su dispositivo singolo Cloud 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 in modo da utilizzare il progetto in cui vuoi creare Cloud TPU.
```
gcloud config set project ${PROJECT_ID}
```
La prima volta che esegui questo comando in una nuova VM Cloud Shell, viene visualizzata una paginaAuthorize Cloud Shell. 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.

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 seguente comando:

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
```
Questo bucket Cloud Storage archivia i dati che utilizzi per addestrare il modello e i risultati dell'addestramento. Il comando gcloud utilizzato in questo tutorial per configurare la TPU configura anche le autorizzazioni predefinite per l'account di servizio Cloud TPU configurato nel passaggio precedente. Se vuoi autorizzazioni più granulari, consulta le autorizzazioni a livello di accesso.

Configura e avvia Cloud TPU

Avvia una VM di Compute Engine e una Cloud TPU utilizzando l'gcloud .
```
$ gcloud compute tpus tpu-vm create retinanet-tutorial \
--zone=europe-west4-a \
--accelerator-type=v3-8 \
--version=tpu-vm-tf-2.17.0-pjrt
```
Descrizioni dei flag dei comandi

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 sei connesso alla VM, il prompt della shell cambia da username@projectname a username@vm-name:
```
gcloud compute tpus tpu-vm ssh retinanet-tutorial --zone=europe-west4-a
```
Punto chiave: da questo punto in poi, un prefisso (vm) $ indica che devi eseguire il comando sull'istanza VM Compute Engine.

Installa pacchetti aggiuntivi

L'applicazione di addestramento RetinaNet richiede diversi pacchetti aggiuntivi. Installalo ora:

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

Installa i requisiti di TensorFlow.

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

Imposta la variabile del nome Cloud TPU.
```
(vm)$ export TPU_NAME=local
```

Aggiungi le variabili di ambiente per le directory dei dati e dei modelli.

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

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

Passa alla directory in cui si trova il modello:

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

Addestramento su un singolo dispositivo Cloud TPU

I seguenti script di addestramento sono stati eseguiti su Cloud TPU v3-8. it richiede più tempo, ma è possibile eseguirle anche su Cloud TPU v2-8.

Lo script di esempio seguente viene addestrato per soli 10 passaggi e richiede meno di 5 minuti per essere eseguito su una TPU v3-8. Per l'addestramento alla convergenza sono necessari circa 22.500 passaggi e circa 1 ora e mezza su una TPU Cloud TPU v3-8.

Configura le seguenti variabili di 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

Esegui lo script di addestramento:
```
(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 } }"
```
Descrizioni dei flag dei comandi

strategy_type

Per addestrare il modello RetinaNet su una TPU, devi impostare distribution_strategy su tpu.

tpu

Il nome della Cloud TPU. Questo viene impostato utilizzando la variabile di ambiente TPU_NAME.

model_dir

Il bucket Cloud Storage in cui vengono archiviati i controlli regolari e i riepiloghi durante l'addestramento. Puoi utilizzare una cartella esistente per caricare i checkpoint generati in precedenza creati su una TPU delle stesse dimensioni e della stessa versione di TensorFlow.

mode

Imposta questo valore su train per addestrare il modello o su eval per valutarlo.

params_override

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

Il modello verrà addestrato per 10 passaggi in circa 5 minuti su una TPU v3-8. Quando l'addestramento è stato completato, vedrai un output simile al seguente:

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
}

Valutazione di un singolo dispositivo Cloud TPU

La seguente procedura utilizza i dati di valutazione del COCO. Sono necessari circa 10 minuti per eseguire i passaggi di valutazione su una TPU v3-8.

Configura le seguenti variabili di ambiente:
```
(vm)$ export EVAL_SAMPLES=5000
```

Esegui lo script di valutazione:

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

Descrizioni flag di comando

strategy_type: La strategia di distribuzione da utilizzare. tpu o multi_worker_gpu.
tpu: Il nome del Cloud TPU. Questo viene impostato utilizzando la variabile di ambiente TPU_NAME.
model_dir: Il bucket Cloud Storage in cui vengono archiviati i controlli regolari e i riepiloghi durante l'addestramento. Puoi utilizzare una cartella esistente per caricarla in precedenza checkpoint generati creati su una TPU delle stesse dimensioni e con TensorFlow completamente gestita.
mode: Uno dei valori train, eval o train_and_eval.
params_override: Una stringa JSON che sostituisce i parametri di script predefiniti. Per ulteriori informazioni sui parametri dello script, consulta /usr/share/models/official/legacy/detection/main.py.

Al termine della valutazione, nella console verranno visualizzati messaggi simili ai seguenti:

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

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

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 retinanet-tutorial \
  --zone=europe-west4-a

Descrizioni dei flag dei comandi

zone: La zona in cui risiede 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 su pod di TPU.

Addestramento di RetinaNet su un pod 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 in modo da utilizzare il progetto in cui vuoi creare 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.

Gli account di servizio consentono al servizio Cloud TPU di accedere ad altri servizi Google Cloud.
```
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 o creato in precedenza per il tuo progetto.

Importante: configura le risorse Cloud TPU e il bucket Cloud Storage nella stessa regione e nella stessa zona per ridurre la latenza e i costi di rete. Le Cloud TPU si trovano in zone specifiche, ovvero suddivisioni all'interno di una regione.

Nel seguente comando, sostituisci europe-west4 con il nome della regione che utilizzerai per eseguire l'addestramento. Sostituisci bucket-name con il nome che vuoi assegnare al tuo bucket.
```
gcloud storage buckets create gs://bucket-name \
  --project=${PROJECT_ID} \
  --location=europe-west4
```
Questo bucket Cloud Storage archivia i dati che utilizzi per addestrare il modello e i risultati dell'addestramento. Il comando gcloud utilizzato in questo tutorial configura le autorizzazioni predefinite per l'account di servizio Cloud TPU configurato nel passaggio precedente. Se vuoi autorizzazioni più granulari, rivedi le autorizzazioni a livello di accesso.

La posizione del bucket deve trovarsi nella stessa regione delle risorse TPU.
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 impostare l'addestramento.
Configura e 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.

Avvia un pod di VM TPU utilizzando il comando gcloud compute tpus tpu-vm. Questo specifica un pod v3-32. Per altre opzioni per i pod, consulta pagina dei tipi di TPU disponibili.
```
$ 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
 
```
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 in un progetto, l'esecuzione di attività di avvio come la propagazione della chiave SSH e l'attivazione dell'API richiede circa 5 minuti.
Connettiti all'istanza VM TPU tramite SSH. Quando sei connesso alla VM, il prompt della shell cambia da username@projectname a username@vm-name:
```
gcloud compute tpus tpu-vm ssh retinanet-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. inizia con (vm)$ nella finestra della sessione VM.

Imposta la variabile del nome Cloud TPU.

(vm)$ export TPU_NAME=retinanet-tutorial

Imposta le variabili del bucket Cloud Storage

Configura le seguenti variabili di ambiente, sostituendo bucket-name con il nome del tuo bucket Cloud Storage:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
```
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/retinanet-train
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```
L'applicazione di addestramento si aspetta che i dati di addestramento siano accessibili in Cloud Storage. L'applicazione di addestramento utilizza anche il tuo Cloud Storage per archiviare i checkpoint durante l'addestramento.

Installa pacchetti aggiuntivi

L'applicazione di addestramento di RetinaNet richiede diversi pacchetti aggiuntivi. Installa li ora:

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

Installa i requisiti di TensorFlow.

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

Imposta alcune variabili di ambiente obbligatorie:

(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

Passa alla directory in cui si trova il modello:

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

Addestra il modello
```
(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}, } }" 
```
Descrizioni flag di comando

tpu

Il nome della TPU.

model_dir

Specifica la directory in cui sono archiviati i checkpoint e i riepiloghi durante l'addestramento del modello. Se la cartella risulta mancante, il programma ne crea una. Se 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 per archiviare checkpoint aggiuntivi, a condizione che i checkpoint precedenti siano stati creati utilizzando una Cloud TPU delle stesse dimensioni e della stessa versione di TensorFlow.

params_override

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

Questa procedura addestra il modello sul set di dati COCO per l'addestramento 5625 passaggi. Questo addestramento richiede circa 20 minuti su una TPU v3-32. Al termine dell'addestramento, viene visualizzato un messaggio simile al seguente:

Al termine dell'addestramento, viene visualizzato un messaggio simile al seguente:

   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}

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 dalla VM di Compute Engine:
```
(vm)$ exit
```
Ora il tuo prompt dovrebbe essere username@projectname e mostrare in Cloud Shell.

Elimina le risorse Cloud TPU e Compute Engine.

$ gcloud compute tpus tpu-vm delete retinanet-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. Una risposta simile alla seguente indica che le istanze sono state eliminate correttamente.
```
$ gcloud compute tpus tpu-vm list --zone=europe-west4-a
```
```
Listed 0 items.
```
Elimina il bucket Cloud Storage. Sostituisci bucket-name con il nome del tuo bucket Cloud Storage.
Elimina il bucket Cloud Storage utilizzando gcloud CLI come mostrato nell'esempio seguente. Sostituisci bucket-name con il nome del tuo bucket Cloud Storage.
```
$ gcloud storage rm gs://bucket-name --recursive
```

Passaggi successivi

I tutorial su TensorFlow Cloud TPU in genere addestrano il modello utilizzando una un set di dati di esempio. I risultati di questo addestramento non sono utilizzabili per l'inferenza. A per l'inferenza, puoi addestrare i dati su una o il tuo set di dati. Modelli TensorFlow addestrati su Cloud TPU richiedono generalmente che i set di dati siano TFRecord.

Puoi utilizzare lo strumento di conversione dei set di dati sample per convertire un'immagine in formato TFRecord. Se non utilizzi un modello di classificazione delle immagini, dovrai convertire autonomamente il tuo set di dati in formato TFRecord. Per ulteriori informazioni, consulta TFRecord e tf.Example.

Ottimizzazione degli iperparametri

Per migliorare le prestazioni del modello con il tuo set di dati, puoi ottimizzare i suoi parametri iperbolici. Puoi trovare informazioni sugli iperparametri comuni a tutti Modelli supportati da TPU su GitHub. Puoi trovare informazioni sugli iperparametri specifici del modello nella fonte per ciascuno un modello di machine learning. Per ulteriori informazioni sull'ottimizzazione degli iperparametri, consulta la Panoramica dell'ottimizzazione degli iperparametri e Ottimizzare gli iperparametri.

Inferenza

Una volta addestrato il modello, puoi utilizzarlo per l'inferenza (chiamata anche previsione). Puoi utilizzare il convertitore di inferenza di Cloud TPU strumento per preparare e ottimizzare Modello TensorFlow per l'inferenza su Cloud TPU v5e. Per maggiori informazioni informazioni sull'inferenza su Cloud TPU v5e, consulta Inferenza di Cloud TPU v5e introduzione.

Addestramento con immagini di dimensioni diverse

Puoi esplorare utilizzando una rete backbone più grande (ad esempio, ResNet-101 invece di ResNet-50). Un'immagine di input più grande e una spina dorsale più potente produrranno più lento, ma più preciso.

Utilizza una base di calcolo diversa

In alternativa, puoi esplorare l'addestramento preliminare di un modello ResNet sul tuo set di dati e utilizzarlo come base per il tuo modello RetinaNet. Con un po' di lavoro extra, anche passare a una rete backbone alternativa al posto di ResNet. Infine, Se ti interessa implementare modelli di rilevamento degli oggetti, questo possono essere una buona base per ulteriori esperimenti.