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à dimestichezza 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 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, controlla che il progetto Google Cloud sia configurato correttamente.

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. Consulta la pagina Prezzi per 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 risorse Cloud Storage, VM e Cloud TPU per l'addestramento di un singolo dispositivo.

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

In 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.

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 e i risultati dell'addestramento. Lo strumento gcloud compute tpus tpu-vm 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.

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 preparare il 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=us-central2
```

Crea una VM Compute Engine per scaricare e pre-elaborare il set di dati. Per ulteriori informazioni, consulta Creare e avviare 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 Da username@projectname a username@vm-name.
Configura due variabili, una per il bucket di archiviazione creato 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 insieme di file TFRecord (*.tfrecord) previsti dall'applicazione di addestramento.
```
(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 anche copiare i file di annotazioni. Questi file consentono di convalidare le prestazioni del modello.
```
(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 ora dovrebbe essere username@projectname, a indicare che ti trovi in in Cloud Shell.

Elimina la VM Compute Engine:

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

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, consulta Versioni di 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 punto in poi, un prefisso (vm) $ indica che devi eseguire il comando sull'istanza VM 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 si trova il modello:

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

Aggiungi alcune variabili di ambiente richieste:

(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. L'addestramento fino alla convergenza richiede circa 22.500 passaggi 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 distribution_strategy su tpu.

tpu

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

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 dello script predefiniti. Per maggiori 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 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: 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 ulteriori informazioni sui parametri dello 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 dei flag dei comandi

zone

La zona in cui Cloud TPU ha risieduto.

A questo punto, puoi concludere questo tutorial ed eseguire le operazioni di pulizia oppure continuare ed esplorare l'esecuzione del modello sui pod Cloud TPU.

Eseguire il scaling del modello con i pod Cloud TPU

L'addestramento del modello sui pod 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, viene visualizzata una paginaAuthorize Cloud Shell. Fai clic su Authorize in fondo alla pagina per consentire a gcloud di effettuare chiamate API Google Cloud con le tue 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.
```
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 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, 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 TPU, puoi mettere in coda la richiesta utilizzando le risorse in coda. Le risorse in coda ti consentono di ricevere la capacità non appena diventa disponibile. Per richiedere le risorse Cloud TPU come risorse in coda, utilizza il comando gcloud compute tpus queued-resources create. Per saperne di più, consulta Gestire le 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, consulta Versioni di TPU.

version

La versione software di Cloud TPU.

Nota: la prima volta che esegui gcloud su un progetto ci vuole 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 sei connesso alla VM, il prompt della shell cambia 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 esegui 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 richieste:

(vm)$ export PYTHONPATH="/usr/share/tpu/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

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 del Cloud TPU. Viene impostato utilizzando TPU_NAME variabile di ambiente.

model_dir

La directory in cui vengono archiviati i controlli regolari e i riepiloghi 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 dello script predefiniti. Per maggiori 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 lo hai già fatto Fatto:
```
(vm)$ exit
```
Il tuo prompt dovrebbe ora essere username@projectname, a indicare che ti trovi 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. L'eliminazione potrebbe richiedere alcuni 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 creato per questo tutorial:

Attenzione: tutti i dati di addestramento andranno persi quando elimini il bucket, quindi svolgi questo passaggio solo al termine dell'esecuzione del tutorial.
```
$ gcloud storage rm gs://bucket-name --recursive
```

Passaggi successivi

Addestramento con immagini di dimensioni diverse

Puoi provare a utilizzare una rete neurale più grande (ad esempio ResNet-101 anziché ResNet-50). Un'immagine di input più grande e una rete neurale più potente produrranno un modello più lento, ma più preciso.

Utilizza una base di calcolo 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 impegno, puoi anche sostituire ResNet con una rete neurale alternativa. Infine, se ti interessa implementare i tuoi modelli di rilevamento degli oggetti, questa rete potrebbe essere una buona base per ulteriori esperimenti.

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

Obiettivi

Costi

Prima di iniziare

Addestramento su dispositivo singolo Cloud TPU

Prepara il set di dati COCO

Avvia le risorse TPU e addestra il modello

Descrizioni flag di comando

Descrizioni flag di comando

Descrizioni flag di comando

Descrizioni dei flag dei comandi

Eseguire il scaling del modello con i pod Cloud TPU

Addestramento dei pod di TPU

Descrizioni flag di comando

Descrizioni flag di comando

Esegui la pulizia

Passaggi successivi

Addestramento con immagini di dimensioni diverse

Utilizza una base di calcolo diversa