Addestramento DLRM su Cloud TPU con PyTorch

Questo tutorial mostra come addestrare le DLRM di Facebook Research su una Cloud TPU.

Obiettivi

Crea e configura l'ambiente PyTorch
Esegui il job di addestramento con dati falsi
(Facoltativo) Esegui l'addestramento sul set di dati Criteo Kaggle

Costi

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

Compute Engine
Cloud TPU

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

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 di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

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

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

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

Questa procedura dettagliata utilizza i componenti fatturabili di Google Cloud. Consulta la pagina dei prezzi di Cloud TPU per una stima dei costi. Assicurati di ripulire le risorse che crei quando hai finito di utilizzarle, per evitare addebiti non necessari.

Configura un'istanza di Compute Engine

Apri una finestra di Cloud Shell.

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

Da Cloud Shell, avvia la risorsa Compute Engine necessaria per questo tutorial. Nota: dovrai utilizzare un n1-highmem-96 machine-type se semplice addestramento su set di dati Criteo Kaggle.

gcloud compute instances create dlrm-tutorial \
--zone=us-central1-a \
--machine-type=n1-standard-64 \
--image-family=torch-xla \
--image-project=ml-images  \
--boot-disk-size=200GB \
--scopes=https://www.googleapis.com/auth/cloud-platform

Connettiti alla nuova istanza di Compute Engine.
```
gcloud compute ssh dlrm-tutorial --zone=us-central1-a
```
Punto chiave: da questo punto in poi, il prefisso (vm) $ indica che devi eseguire il comando sull'istanza VM di Compute Engine.

Avvia una risorsa Cloud TPU

Dalla macchina virtuale Compute Engine, avvia una risorsa Cloud TPU utilizzando il comando seguente:

(vm) $ gcloud compute tpus create dlrm-tutorial \
--zone=us-central1-a \
--network=default \
--version=pytorch-2.0  \
--accelerator-type=v3-8

Identificare l'indirizzo IP della risorsa Cloud TPU.
```
(vm) $ gcloud compute tpus describe dlrm-tutorial --zone=us-central1-a
```
Importante: l'indirizzo IP interno è visualizzato anche nella console di Google Cloud, in Compute Engine > TPU. Dovrai avere questo indirizzo IP senza il numero di porta quando crei e configuri l'ambiente PyTorch.

Crea e configura l'ambiente PyTorch

Avvia un ambiente conda.
```
(vm) $ conda activate torch-xla-2.0
```
Configura le variabili di ambiente per la risorsa Cloud TPU.

Nota: la variabile TPU_IP_ADDRESS deve corrispondere all'indirizzo IP della Cloud TPU che hai identificato durante il lancio della risorsa Cloud TPU.
```
(vm) $ export TPU_IP_ADDRESS=ip-address
```
```
(vm) $ export XRT_TPU_CONFIG="tpu_worker;0;$TPU_IP_ADDRESS:8470"
```

Esegui il job di addestramento con dati falsi

Installa le dipendenze.
```
(vm) $ pip install onnx
```

Eseguire il modello su dati casuali. L'operazione dovrebbe richiedere 5-10 minuti.

(vm) $ python /usr/share/torch-xla-2.0/tpu-examples/deps/dlrm/dlrm_tpu_runner.py \
    --arch-embedding-size=1000000-1000000-1000000-1000000-1000000-1000000-1000000-1000000 \
    --arch-sparse-feature-size=64 \
    --arch-mlp-bot=512-512-64 \
    --arch-mlp-top=1024-1024-1024-1 \
    --arch-interaction-op=dot \
    --lr-num-warmup-steps=10 \
    --lr-decay-start-step=10 \
    --mini-batch-size=2048 \
    --num-batches=1000 \
    --data-generation='random' \
    --numpy-rand-seed=727 \
    --print-time \
    --print-freq=100 \
    --num-indices-per-lookup=100 \
    --use-tpu \
    --num-indices-per-lookup-fixed \
    --tpu-model-parallel-group-len=8 \
    --tpu-metrics-debug \
    --tpu-cores=8

(Facoltativo) Esegui l'addestramento sul set di dati Criteo Kaggle

Questi passaggi sono facoltativi. Devi eseguirle solo se vuoi addestrare il set di dati Criteo Kaggle.

Scarica il set di dati.

Scarica il set di dati da Criteo Kaggle seguendo le istruzioni riportate qui. Al termine del download, copia il file dac.tar.gz in una directory denominata ./criteo-kaggle/. Usa il comando tar -xzvf per estrarre i contenuti del file tar.gz nella directory ./critero-kaggle.
```
 (vm) $ mkdir criteo-kaggle
 (vm) $ cd criteo-kaggle
 (vm) $ # Download dataset from above link here.
 (vm) $ tar -xzvf dac.tar.gz
 (vm) $ cd ..
```

Pre-elabora il set di dati.

Inizia questo script per pre-elaborare il set di dati Criteo. Questo script produce un file denominato kaggleAdDisplayChallenge_processed.npz e richiede più di tre ore per pre-elaborare il set di dati.

(vm) $ python /usr/share/torch-xla-2.0/tpu-examples/deps/dlrm/dlrm_data_pytorch.py \
    --data-generation=dataset \
    --data-set=kaggle \
    --raw-data-file=criteo-kaggle/train.txt \
    --mini-batch-size=128 \
    --memory-map \
    --test-mini-batch-size=16384 \
    --test-num-workers=4

Verifica che la pre-elaborazione sia andata a buon fine.

Dovresti vedere il file kaggleAdDisplayChallenge_processed.npz nella directory criteo-kaggle.

Esegui lo script di addestramento sul set di dati Criteo Kaggle pre-elaborato.

(vm) $ python /usr/share/torch-xla-2.0/tpu-examples/deps/dlrm/dlrm_tpu_runner.py \
    --arch-sparse-feature-size=16 \
    --arch-mlp-bot="13-512-256-64-16" \
    --arch-mlp-top="512-256-1" \
    --data-generation=dataset \
    --data-set=kaggle \
    --raw-data-file=criteo-kaggle/train.txt \
    --processed-data-file=criteo-kaggle/kaggleAdDisplayChallenge_processed.npz \
    --loss-function=bce \
    --round-targets=True \
    --learning-rate=0.1 \
    --mini-batch-size=128 \
    --print-freq=1024 \
    --print-time \
    --test-mini-batch-size=16384 \
    --test-num-workers=4 \
    --memory-map \
    --test-freq=101376 \
    --use-tpu \
    --num-indices-per-lookup=1 \
    --num-indices-per-lookup-fixed \
    --tpu-model-parallel-group-len 8 \
    --tpu-metrics-debug \
    --tpu-cores=8

L'addestramento dovrebbe essere completato in più di 2 ore con una precisione del 78,75%o più.

Esegui la pulizia

Esegui una pulizia per evitare che al tuo account vengano addebitati costi non necessari dopo l'utilizzo delle risorse che hai creato:

Disconnettiti dall'istanza di Compute Engine, se non l'hai ancora fatto:
```
(vm) $ exit
```
La richiesta dovrebbe essere user@projectname, a indicare che sei in Cloud Shell.
In Cloud Shell, utilizza Google Cloud CLI per eliminare l'istanza di Compute Engine:
```
$ gcloud compute instances delete dlrm-tutorial --zone=us-central1-a
```

Utilizza Google Cloud CLI per eliminare la risorsa Cloud TPU.

$ gcloud compute tpus delete dlrm-tutorial --zone=us-central1-a

Passaggi successivi

Prova i lab PyTorch: