Addestramento ShapeMask su Cloud TPU

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 su Cloud TPU. Se non hai mai utilizzato Cloud TPU, puoi consultare la guida rapida per un'introduzione di base.

Se prevedi di addestrare una sezione di un pod di TPU, consulta Formazione sui pod di TPU per comprendere le modifiche ai parametri richieste per le sezioni dei pod.

Obiettivi

Crea un bucket Cloud Storage per contenere l'output del set di dati e il modello
Prepara il set di dati COCO
Configura una VM di Compute Engine e un nodo Cloud TPU per l'addestramento e la valutazione
Esegui addestramento e valutazione su una singola Cloud TPU o un pod di Cloud TPU

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Compute Engine
Cloud TPU
Cloud Storage

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono beneficiare di una prova gratuita.

Prima di iniziare

Prima di iniziare questo tutorial, verifica che il tuo progetto Google Cloud sia configurato correttamente.

Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

Questa procedura dettagliata utilizza componenti fatturabili di Google Cloud. Consulta la pagina Prezzi di Cloud TPU per una stima dei costi. Assicurati di pulire le risorse che crei quando hai finito di utilizzarle per evitare addebiti inutili.

Se prevedi di addestrare una sezione di un pod di TPU, consulta Formazione sui pod di TPU per comprendere le modifiche dei parametri necessarie per le sezioni dei pod.

Configura le risorse

Questa sezione fornisce informazioni sulla configurazione delle risorse di Cloud Storage, VM e Cloud TPU per questo tutorial.

Apri una finestra di Cloud Shell.

Apri Cloud Shell
Crea una variabile per l'ID del tuo progetto.
```
export PROJECT_ID=project-id
```
Configura l'interfaccia a riga di comando di Google Cloud per 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 di Cloud Shell, viene visualizzata una pagina Authorize Cloud Shell. Fai clic su Authorize in fondo alla pagina per consentire a gcloud di effettuare chiamate API GCP con le tue credenziali.

Crea 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 formato seguente:

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

Crea un bucket Cloud Storage utilizzando il seguente comando:

Nota: nel comando seguente, sostituisci bucket-name con il nome che vuoi assegnare al bucket.
```
gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -b on gs://bucket-name
```
Questo bucket Cloud Storage archivia i dati che utilizzi per addestrare il modello e 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. Se vuoi le autorizzazioni finin-grain, consulta le autorizzazioni per il livello di accesso.

La località del bucket deve essere nella stessa area geografica della macchina virtuale (VM) e del nodo TPU. Le VM e i nodi TPU si trovano in zone specifiche, che sono suddivisioni all'interno di un'area geografica.
Avvia un'istanza VM di Compute Engine.

Nota: questo tutorial utilizza TensorFlow 1.15.5, che si basa sull'immagine Debian 10 e utilizza per impostazione predefinita Python 3.6. Le versioni precedenti di TensorFlow 1.15.x erano basate su Debian 9 e predefinite per Python 3.5.
```
$ gcloud compute tpus execution-groups create --vm-only \
 --name=shapemask-tutorial \
 --zone=us-central1-a \
 --disk-size=300 \
 --machine-type=n1-standard-16 \
 --tf-version=1.15.5
```
Descrizioni flag 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 Cloud TPU.

disk-size

Le dimensioni del disco rigido in GB della VM creata dal comando gcloud compute tpus execution-groups.

machine-type

Il tipo di macchina della VM di Compute Engine da creare.

tf-version

La versione di Tensorflow ctpu viene installata sulla VM.
Viene visualizzata la configurazione da te specificata. Inserisci y per approvare o n per annullare.

Nota: la prima volta che esegui gcloud compute tpus execution-groups su un progetto, sono necessari circa 5 minuti per eseguire attività di avvio, come la propagazione della chiave SSH e la visualizzazione delle API.

Una volta completata l'esecuzione del comando gcloud compute tpus execution-groups, verifica che il messaggio della shell sia cambiato da username@projectname a username@vm-name. Questa modifica mostra che hai eseguito l'accesso alla tua VM di Compute Engine.

Nota: se non hai effettuato la connessione all'istanza di Compute Engine, per connetterti puoi eseguire questo comando:
```
gcloud compute ssh shapemask-tutorial --zone=us-central1-a
```
Mentre continui a seguire queste istruzioni, esegui ciascun comando che inizia con (vm)$ nella tua istanza di Compute Engine.
Crea una variabile di ambiente per archiviare la località del bucket Cloud Storage.
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
Crea una variabile di ambiente per la directory dei dati.
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```

Clona il repository tpu.

(vm)$ git clone -b shapemask https://github.com/tensorflow/tpu/

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"

Prepara il set di dati COCO

Esegui lo script download_and_preprocess_coco.sh per convertire il set di dati COCO in un insieme di TFRecord (*.tfrecord) previsto.

Nota: lo script di download e conversione di COCO richiede circa un'ora.
```
(vm)$ sudo bash /usr/share/tpu/tools/datasets/download_and_preprocess_coco.sh ./data/dir/coco
```
Vengono installate le librerie richieste ed eseguito lo script di pre-elaborazione. Nella directory dei dati locali viene restituito un numero di file *.tfrecord.
Dopo aver convertito i dati in TFRecord, copiali dallo spazio di archiviazione locale nel tuo bucket Cloud Storage utilizzando il comando gsutil. Devi anche copiare i file di annotazione. Questi file consentono di convalidare le prestazioni del modello:
```
(vm)$ gsutil -m cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gsutil cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```
Nota: se vuoi monitorare l'output e le prestazioni del modello, segui la guida alla configurazione di TensorBoard.

Configurazione e avvio di Cloud TPU

Avvia una risorsa Cloud TPU utilizzando il comando gcloud.
```
(vm)$ gcloud compute tpus execution-groups create \
 --tpu-only \
 --accelerator-type=v3-8  \
 --name=shapemask-tutorial \
 --zone=us-central1-a \
 --tf-version=1.15.5
```
Descrizioni flag comando

tpu-only

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

accelerator-type

Il tipo di Cloud TPU da creare.

name

Il nome della Cloud TPU da creare.

zone

La zona in cui prevedi di creare Cloud TPU.

tf-version

La versione di Tensorflow ctpu viene installata sulla VM.
Viene visualizzata la configurazione da te specificata. Inserisci y per approvare o n per annullare.

Verrà visualizzato un messaggio: Operation success; not ssh-ing to Compute Engine VM due to --tpu-only flag. Poiché in precedenza hai completato la propagazione della chiave SSH, puoi ignorare questo messaggio.
Aggiungi una variabile di ambiente per il nome della tua Cloud TPU.
```
(vm)$ export TPU_NAME=shapemask-tutorial
```

Eseguire lo script di addestramento e valutazione

Crea le seguenti variabili di ambiente:

(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/shapemask_exp
(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/shapemask/retinanet/resnet101-checkpoint-2018-02-24
(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 PYTHONPATH=${PYTHONPATH}:$HOME/tpu/models

Esegui il seguente script per eseguire l'addestramento.

Nota: l'esecuzione dello script richiede circa 25 minuti.
```
(vm)$ python3 ~/tpu/models/official/detection/main.py \
--model=shapemask \
--use_tpu=True \
--tpu=${TPU_NAME} \
--num_cores=8 \
--model_dir=${MODEL_DIR} \
--mode="train" \
--eval_after_training=False \
--params_override="{train: {iterations_per_loop: 1000, train_batch_size: 64, total_steps: 1000, learning_rate: {total_steps: 1000, warmup_learning_rate: 0.0067, warmup_steps: 500, init_learning_rate: 0.08, learning_rate_levels: [0.008, 0.0008], learning_rate_steps: [30000, 40000]}, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet101/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, resnet: {resnet_depth: 101}, 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: [1024, 1024]}, }"
```
Descrizioni flag comando

model

Il modello da addestrare.

use_tpu

Imposta su true per l'addestramento su una Cloud TPU.

tpu_name

Il nome della Cloud TPU da utilizzare per l'addestramento.

num_cores

Il numero di core Cloud TPU da utilizzare durante l'addestramento.

model_dir

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

mode

Uno di train, eval o train_and_eval.

eval_after_training

Impostare true per valutare il modello dopo l'addestramento,

params_override

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

A questo punto, puoi completare questo tutorial e ripulire le tue risorse GCP. In alternativa, puoi esplorare ulteriormente il modello su un pod Cloud TPU.

Scalabilità del modello con i pod Cloud TPU

Puoi ottenere risultati più velocemente scalando il tuo modello con i pod di Cloud TPU. Il modello Mask RCNN completamente supportato può funzionare con le seguenti sezioni di pod:

v2-32
v3-32

Quando lavori con i pod di Cloud TPU, devi prima addestrare il modello utilizzando un pod, poi utilizzare un singolo dispositivo Cloud TPU per valutarlo.

Addestramento con pod di Cloud TPU

Se hai già eliminato la tua istanza Compute Engine, creane una nuova seguendo i passaggi descritti in Configura le tue risorse.

Elimina la risorsa Cloud TPU creata per addestrare il modello su un singolo dispositivo.

(vm)$ gcloud compute tpus execution-groups delete shapemask-tutorial \
  --zone=us-central1-a \
  --tpu-only

Vai al bucket Cloud Storage ed elimina il file checkpoint.
Esegui il comando gcloud compute tpus execution-groups, utilizzando il parametro accelerator-type per specificare la sezione del pod da utilizzare. Ad esempio, il comando seguente utilizza una sezione di pod v3-32.
```
(vm)$ gcloud compute tpus execution-groups  create --name=shapemask-tutorial \
  --accelerator-type=v2-32  \
  --zone=us-central1-a \
  --tf-version=1.15.5 \
  --tpu-only
```
Descrizioni flag comando

name

Il nome della Cloud TPU da creare.

accelerator-type

Il tipo di Cloud TPU da creare.

zone

La zona in cui prevedi di creare Cloud TPU.

tf-version

La versione di Tensorflow gcloud viene installata sulla VM.

tpu-only

Crea solo Cloud TPU. Per impostazione predefinita, il comando gcloud crea una VM e una Cloud TPU.
Esegui lo script seguente per addestrare il modello su un pod.

L'esecuzione dello script di addestramento con circa 45 minuti è necessaria. Per eseguire la convergenza, imposta total_steps su 22000.
```
(vm)$ python3 ~/tpu/models/official/detection/main.py \
--model shapemask \
--use_tpu=True \
--tpu=${TPU_NAME} \
--num_cores=32 \
--model_dir=${MODEL_DIR} \
--mode="train" \
--eval_after_training=False \
--params_override="{train: {iterations_per_loop: 1000, train_batch_size: 256, total_steps: 1000, learning_rate: {total_steps: 1000, warmup_learning_rate: 0.0067, warmup_steps: 500, init_learning_rate: 0.08, learning_rate_levels: [0.008, 0.0008], learning_rate_steps: [15000, 20000]}, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet101/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, resnet: {resnet_depth: 101}, 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: [1024, 1024]}, }"
```
Descrizioni flag comando

strategy_type

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

tpu

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

model_dir

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

mode

Uno di train, eval o train_and_eval.

model

Il modello da addestrare.

eval_after_training

Impostare true per valutare il modello dopo l'addestramento,

params_override

Una stringa JSON che sostituisce i parametri di script predefiniti. Per ulteriori informazioni sui parametri dello script, consulta /usr/share/models/official/vision/detection/main.py.
Il modello deve essere valutato su un singolo dispositivo Cloud TPU. Elimina il dispositivo pod Cloud TPU.
```
$ gcloud compute tpus execution-groups delete shapemask-tutorial \
  --zone=us-central1-a
```
Creare una singola risorsa Cloud TPU.
```
(vm)$ gcloud compute tpus execution-groups create \
 --tpu-only \
 --accelerator-type=v3-8  \
 --name=shapemask-tutorial \
 --zone=us-central1-a \
 --tf-version=1.15.5
```
Descrizioni flag comando

tpu-only

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

tpu-size

Il tipo di Cloud TPU da creare.

name

Il nome della Cloud TPU da creare.

zone

La zona in cui prevedi di creare Cloud TPU.

tf-version

La versione di Tensorflow ctpu viene installata sulla VM.

Esegui lo script per eseguire la valutazione.

(vm)$ python3 ~/tpu/models/official/detection/main.py \
--model shapemask \
--use_tpu=True \
--tpu=${TPU_NAME} \
--num_cores=8 \
--model_dir=${MODEL_DIR} \
--mode="eval" \
--eval_after_training=False \
--params_override="{train: {iterations_per_loop: 1000, train_batch_size: 256, total_steps: 1000, learning_rate: {total_steps: 1000, warmup_learning_rate: 0.0067, warmup_steps: 500, init_learning_rate: 0.08, learning_rate_levels: [0.008, 0.0008], learning_rate_steps: [15000,20000]}, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet101/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, resnet: {resnet_depth: 101}, 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: [1024, 1024]}, }"

Descrizioni flag comando

model: Il modello da addestrare.
use_tpu: Imposta su true per l'addestramento su una Cloud TPU.
tpu: Il nome della Cloud TPU. Per questo viene impostato utilizzando la variabile di ambiente TPU_NAME.
num_cores: Il numero di core Cloud TPU da utilizzare durante l'addestramento.
model_dir: Il bucket Cloud Storage, in cui i punti di controllo e i riepiloghi vengono archiviati durante l'addestramento. Puoi utilizzare una cartella esistente per caricare punti di controllo generati in precedenza creati su una TPU delle stesse dimensioni e versione di TensorFlow.
mode: Uno di train, eval o train_and_eval.
eval_after_training: Impostare true per valutare il modello dopo l'addestramento,
params_override: Una stringa JSON che sostituisce i parametri di script predefiniti. Per ulteriori informazioni sui parametri dello script, consulta /usr/share/models/official/vision/detection/main.py.

L'output dello script di valutazione ha il seguente aspetto:

Eval result: {
 'AP75': 0.116238795,
 'AP': 0.121657856,
 'mask_ARmax100': 0.29928473,
 'APl': 0.17029367,
 'mask_ARmax1': 0.17677748,
 'ARs': 0.14137766,
 'mask_AP': 0.12017078,
 'ARmax10': 0.29230836,
 'mask_AP50': 0.20920053,
 'ARm': 0.34366703,
 'AP50': 0.22949784,
 'mask_ARl': 0.41743836,
 'mask_ARs': 0.12669834,
 'APs': 0.046222884,
 'mask_APs': 0.041104294,
 'mask_APl': 0.17535995,
 'mask_ARm': 0.34216145,
 'mask_ARmax10': 0.28690106,
 'APm': 0.14354791,
 'ARmax100': 0.3058479,
 'ARmax1': 0.17576972,
 'ARl': 0.41305476,
 'mask_APm': 0.1422335,
 'mask_AP75': 0.12010279
}

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.

Disconnetti dall'istanza Compute Engine.
```
(vm)$ exit
```
Il tuo prompt dovrebbe ora essere username@projectname, a indicare che ti trovi in Cloud Shell.
In Cloud Shell, utilizza il comando seguente per eliminare la VM di Compute Engine e Cloud TPU:
```
$ gcloud compute tpus execution-groups delete shapemask-tutorial \
  --zone=us-central1-a
```
Verifica che le risorse siano state eliminate eseguendo gcloud compute tpus execution-groups list. L'eliminazione può richiedere qualche minuto. Una risposta simile alla seguente indica che le istanze sono state eliminate correttamente.
```
$ gcloud compute tpus execution-groups list \
 --zone=us-central1-a
```
Dovresti vedere un elenco vuoto di TPU come segue:
```
   NAME             STATUS
```
Elimina il bucket Cloud Storage utilizzando gsutil come mostrato di seguito. Sostituisci bucket-name con il nome del tuo bucket Cloud Storage.

Attenzione: tutti i dati di addestramento andranno persi quando elimini il bucket, quindi esegui questo passaggio solo quando hai completato l'esecuzione del tutorial.
```
$ gsutil rm -r gs://bucket-name
```

Passaggi successivi

I tutorial di TensorFlow Cloud TPU in genere addestrano il modello utilizzando un set di dati di esempio. I risultati di questo corso di formazione non sono utilizzabili per inferenza. Per utilizzare un modello di inferenza, puoi addestrare i dati su un set di dati disponibile pubblicamente o sul tuo set di dati. In genere, i modelli TensorFlow addestrati su Cloud TPU richiedono che i set di dati siano in formato TFRecord.

Puoi utilizzare l'esempio di strumento di conversione del set di dati per convertire un set di dati di classificazione delle immagini in formato TFRecord. Se non utilizzi un modello di classificazione delle immagini, dovrai convertire personalmente il set di dati in formato TFRecord. Per ulteriori informazioni, vedi TFRecord e tf.Example.

Ottimizzazione degli iperparametri

Per migliorare le prestazioni del modello con il tuo set di dati, puoi regolare gli iperparametri di questo modello. Puoi trovare informazioni sugli iperparametri in comune in tutti i modelli supportati da TPU su GitHub. Puoi trovare informazioni sugli iperparametri specifici del modello nel codice sorgente di ciascun modello. Per ulteriori informazioni sull'ottimizzazione degli iperparametri, consulta Panoramica dell'ottimizzazione degli iperparametri, Utilizzo del servizio di ottimizzazione degli iperparametri e Perfezionamento degli iperparametri.

Inferenza

Dopo aver addestrato il modello, puoi utilizzarlo per inferenza (chiamato anche previsione). AI Platform è una soluzione basata su cloud per lo sviluppo, l'addestramento e il deployment di modelli di machine learning. Una volta eseguito il deployment di un modello, puoi utilizzare il servizio AI Platform Prediction.

Addestramento con dimensioni di immagini diverse

Puoi provare a utilizzare una rete neurale più ampia (ad esempio, ResNet-101 anziché ResNet-50). Un'immagine di input più grande e una rete neurale più potente forniranno 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 utilizzarlo come base per il tuo modello ShapeMask. Con qualche lavoro in più, puoi anche scambiare la rete neurale alternativa al posto di ResNet. Infine, se ti interessa implementare modelli di rilevamento degli oggetti, questa rete potrebbe essere una buona base per ulteriori esperimenti.