Addestramento di Cloud TPU v5e

Cloud TPU v5e è l'acceleratore AI di ultima generazione di Google Cloud. Con un minore di 256 chip per pod, una v5e è ottimizzata per offrire prodotto per transformer, conversione da testo a immagine e CNN (Convolutional Neural Network). l'addestramento, il perfezionamento e la pubblicazione. Per ulteriori informazioni sull'utilizzo di Cloud TPU v5e per la pubblicazione, vedi Inferenza tramite v5e.

Per ulteriori informazioni sull'hardware e sulle configurazioni di Cloud TPU v5e TPU, vedi TPU v5e

Inizia

Le sezioni seguenti descrivono come iniziare a utilizzare TPU v5e.

Quota per le richieste

È necessaria una quota per utilizzare TPU v5e per l'addestramento. Esistono diversi tipi di quota TPU on demand, TPU riservate e VM spot TPU. Esistono diversi quote richieste se utilizzi TPU v5e inferenza. Per ulteriori informazioni sulle quote, consulta Quote. Per richiedere la quota TPU v5e, contatta Cloud Vendite.

Creare un account e un progetto Google Cloud

Per utilizzare Cloud TPU devi avere un account e un progetto Google Cloud. Per ulteriori informazioni consulta la sezione Configurare una Cloud TPU encoder-decoder.

Nota: per utilizzare TPU v5e, devi installare gcloud alpha componenti.

Crea una Cloud TPU

La best practice è eseguire il provisioning di Cloud TPU v5es in coda di grandi dimensioni con queued-resource create . Per ulteriori informazioni, consulta la sezione Gestire i messaggi in coda Google Cloud.

Puoi anche utilizzare l'API Create Node (gcloud alpha compute tpus tpu-vm create) per eseguire il provisioning di Cloud TPU v5es. Per ulteriori informazioni, consulta Gestire le TPU Google Cloud.

Per ulteriori informazioni sulle configurazioni v5e per l'addestramento, consulta Tipi di Cloud TPU v5e per addestramento.

Configurazione del framework

Questa sezione descrive il processo di configurazione generale per l'addestramento di modelli personalizzati utilizzando JAX o PyTorch con TPU v5e. L'assistenza per TensorFlow è disponibile in tpu-vm-tf-2.16.1-pjrt e tpu-vm-tf-2.16.1-pod-pjrt TPU le versioni di runtime.

Per istruzioni sulla configurazione dell'inferenza, consulta Inferenza v5e introduzione.

Configurazione per JAX

Se hai forme di sezioni maggiori di 8 chip, avrai più VM in una sezione. In questo caso, devi utilizzare il flag --worker=all per eseguire su tutte le VM TPU in un solo passaggio senza utilizzare SSH per accedere separatamente:

gcloud compute tpus tpu-vm ssh ${TPU_NAME}  \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='pip install "jax[tpu]==0.4.16" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html'

Per verificare il numero di dispositivi, puoi eseguire questo comando (gli output mostrati qui sono stati prodotti con una sezione v5litepod-16). Questo codice verifica che tutto sia installato correttamente controllando che JAX riconosca i TensorCore di Cloud TPU e può eseguire operazioni di base:

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='python3 -c "import jax; print(jax.device_count()); print(jax.local_device_count())"'

L'output sarà simile al seguente:

SSH: Attempting to connect to worker 0...
SSH: Attempting to connect to worker 1...
SSH: Attempting to connect to worker 2...
SSH: Attempting to connect to worker 3...
16
4
16
4
16
4
16
4

jax.device_count() mostra il numero totale di chip nella sezione specificata. jax.local_device_count() indica il numero di chip accessibili a un singolo in questa sezione.

# Check the number of chips in the given slice by summing the count of chips
# from all VMs through the
# jax.local_device_count() API call.
gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='python3 -c "import jax; xs=jax.numpy.ones(jax.local_device_count()); print(jax.pmap(lambda x: jax.lax.psum(x, \"i\"), axis_name=\"i\")(xs))"'

L'output sarà simile al seguente:

SSH: Attempting to connect to worker 0...
SSH: Attempting to connect to worker 1...
SSH: Attempting to connect to worker 2...
SSH: Attempting to connect to worker 3...
[16. 16. 16. 16.]
[16. 16. 16. 16.]
[16. 16. 16. 16.]
[16. 16. 16. 16.]

Prova i tutorial per JavaScript di questo documento per iniziare addestramento v5e con JAX.

Configurazione di PyTorch

Tieni presente che la versione v5e supporta solo il runtime PJRT. mentre PyTorch 2.1+ utilizzerà PJRT come runtime predefinito per tutte le versioni di TPU.

Questa sezione descrive come iniziare a usare PJRT su v5e con PyTorch/XLA con per tutti i worker.

Installa le dipendenze

gcloud compute tpus tpu-vm ssh ${TPU_NAME}  \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='
      sudo apt-get update -y
      sudo apt-get install libomp5 -y
      pip3 install mkl mkl-include
      pip3 install tf-nightly tb-nightly tbp-nightly
      pip3 install numpy
      sudo apt-get install libopenblas-dev -y
      pip3 install torch~=2.1.0 torchvision torch_xla[tpu]~=2.1.0 -f https://storage.googleapis.com/libtpu-releases/index.html
      pip3 install torch_xla[tpu] -f https://storage.googleapis.com/libtpu-releases/index.html'

Se ricevi un errore durante l'installazione delle ruote per torch, torch_xla o torchvision Mi piace pkg_resources.extern.packaging.requirements.InvalidRequirement: Expected end or semicolon (after name and no valid version specifier) torch==nightly+20230222, esegui il downgrade della tua versione con questo comando:

pip3 install setuptools==62.1.0

Esegui uno script con PJRT

Nota: per i modelli che hanno allocazioni considerevoli e frequenti, utilizzando tcmalloc può migliorare significativamente i tempi di addestramento rispetto al valore predefinito di malloc pertanto il valore malloc predefinito utilizzato su una VM TPU tcmalloc. Tuttavia, a seconda del carico di lavoro (ad esempio, DLRM che ha allocazioni molto grandi per le sue tabelle di incorporamento) tcmalloc potrebbe causare un rallentamento. In questo caso potresti provare a annullare l'impostazione della seguente variabile utilizzando invece il valore predefinito malloc:

unset LD_PRELOAD

Di seguito è riportato un esempio in cui viene utilizzato uno script Python per eseguire un calcolo. su una VM v5e:

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker all \
   --command='
      export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$HOME/.local/lib/
      export PJRT_DEVICE=TPU_C_API
      export PT_XLA_DEBUG=0
      export USE_TORCH=ON
      unset LD_PRELOAD
      export TPU_LIBRARY_PATH=$HOME/.local/lib/python3.10/site-packages/libtpu/libtpu.so
      python3 -c "import torch; import torch_xla; import torch_xla.core.xla_model as xm; print(xm.xla_device()); dev = xm.xla_device(); t1 = torch.randn(3,3,device=dev); t2 = torch.randn(3,3,device=dev); print(t1 + t2)"'

In questo modo viene generato un output simile al seguente:

SSH: Attempting to connect to worker 0...
SSH: Attempting to connect to worker 1...
xla:0
tensor([[ 1.8611, -0.3114, -2.4208],
[-1.0731, 0.3422, 3.1445],
[ 0.5743, 0.2379, 1.1105]], device='xla:0')
xla:0
tensor([[ 1.8611, -0.3114, -2.4208],
[-1.0731, 0.3422, 3.1445],
[ 0.5743, 0.2379, 1.1105]], device='xla:0')

Prova i tutorial su PyTorch di questo documento per iniziare a utilizzare addestramento v5e con PyTorch.

Elimina la TPU e la risorsa in coda al termine della sessione. Per eliminare un risorsa in coda, elimina la sezione e poi la risorsa in coda in 2 passaggi:

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Questi due passaggi possono essere utilizzati anche per rimuovere le richieste di risorse in coda lo stato FAILED.

Esempi per JAX/FLAX

Le seguenti sezioni descrivono esempi di come addestrare modelli JAX e FLAX su TPU v5e.

Addestra ImageNet su v5e

Questo tutorial descrive come addestrare ImageNet su v5e utilizzando dati di input falsi. Se Se vuoi utilizzare dati reali, consulta il file README su GitHub.

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=your_tpu_name
   export QUEUED_RESOURCE_ID=your_queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU quando la risorsa in coda si trova lo stato ACTIVE:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID}  \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando QueuedResource è nello stato ACTIVE, l'output sarà simile al seguente:

    state: ACTIVE
   

3. Installa la versione più recente di JAX e jaxlib:

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='pip install "jax[tpu]==0.4.16" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html'
   

   Nota: se viene visualizzato un errore che suggerisce di utilizzare jax>=0.4.8, puoi tranquillamente ignorarlo il messaggio.

4. Clona il modello ImageNet e installa i requisiti corrispondenti:

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='git clone https://github.com/google/flax.git && cd flax/examples/imagenet && pip install -r requirements.txt && pip install flax==0.7.4'
   

5. Per generare dati falsi, il modello ha bisogno di informazioni sulle dimensioni del set di dati. Questi dati possono essere raccolti dai metadati del set di dati ImageNet:

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} --project=${PROJECT_ID} --zone=${ZONE} --worker=all --command='mkdir -p $HOME/flax/.tfds/metadata/imagenet2012/5.1.0 && curl https://raw.githubusercontent.com/tensorflow/datasets/v4.4.0/tensorflow_datasets/testing/metadata/imagenet2012/5.1.0/dataset_info.json --output $HOME/flax/.tfds/metadata/imagenet2012/5.1.0/dataset_info.json'
   

Addestra il modello

Una volta completati tutti i passaggi precedenti, puoi addestrare il modello.

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='cd flax/examples/imagenet && JAX_PLATFORMS=tpu python3 imagenet_fake_data_benchmark.py'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Modelli FLAX Hugging Face

I modelli Hugging Face implementati in FLAX funzionano da su Cloud TPU v5e. Questa sezione fornisce istruzioni per l'esecuzione i modelli più diffusi.

Addestra ViT su Imagenette

Questo tutorial mostra come addestrare Vision Transformer (ViT) di HuggingFace utilizzando Imagenette con IA veloce su Cloud TPU v5e.

Il modello ViT è stato il primo ad addestrare con successo un encoder Transformer su ImageNet con risultati eccellenti rispetto alle reti convoluzionali. Per ulteriori informazioni informazioni, consulta le seguenti risorse:

• Panoramica di ViT
• Risorsa codice ViT

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=your_tpu_name
   export QUEUED_RESOURCE_ID=your_queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU una volta che la risorsa in coda si trova nello stato ACTIVE:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID}  \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando la risorsa in coda è nello stato ACTIVE, l'output sarà simile a:

    state: ACTIVE
   

3. Installa JAX e la relativa libreria:

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='pip install "jax[tpu]==0.4.16" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html'
   

4. Scarica il repository Hugging Face e requisiti di installazione:

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='git clone https://github.com/huggingface/transformers.git && cd transformers && pip install . && pip install -r examples/flax/_tests_requirements.txt && pip install --upgrade huggingface-hub urllib3 zipp && pip install tensorflow==2.16.1 && pip install -r examples/flax/vision/requirements.txt'
   

5. Scarica il set di dati Imagenette:

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='cd transformers && wget https://s3.amazonaws.com/fast-ai-imageclas/imagenette2.tgz && tar -xvzf imagenette2.tgz'
   

Addestra il modello

Addestra il modello con un buffer pre-mappato a 4 GB.

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='cd transformers && JAX_PLATFORMS=tpu python3 examples/flax/vision/run_image_classification.py --train_dir "imagenette2/train" --validation_dir "imagenette2/val" --output_dir "./vit-imagenette" --learning_rate 1e-3 --preprocessing_num_workers 32 --per_device_train_batch_size 8 --per_device_eval_batch_size 8 --model_name_or_path google/vit-base-patch16-224-in21k --num_train_epochs 3'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Risultati del benchmarking ViT

Lo script di addestramento è stato eseguito su v5litepod-4, v5litepod-16 e v5litepod-64. La la seguente tabella mostra le velocità effettiva con diversi tipi di acceleratori.

Tipo di acceleratore	V5litepod-4	V5litepod-16	V5litepod-64
Epoca	3	3	3
Dimensione batch globale	32	128	512
Velocità effettiva (esempi/sec)	263,40	429,34	470,71

Addestra Diffusion su Pokémon

Questo tutorial mostra come addestrare il modello Stable Diffusion HuggingFace utilizzando Pokémon su Cloud TPU v5e.

Il modello Stable Diffusion è un modello da testo a immagine latente che genera immagini fotorealistiche da qualsiasi input di testo. Per ulteriori informazioni, consulta seguenti risorse:

• Panoramica di Stable Diffusion
• Sorgente del codice di Sttable Diffusion

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=your_tpu_name
   export QUEUED_RESOURCE_ID=queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU quando la risorsa in coda si troverà nello stato ACTIVE:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID}  \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando la risorsa in coda si trova nello stato ACTIVE, l'output sarà simile al seguente:

    state: ACTIVE
   

3. Installa JAX e la relativa libreria.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='pip install "jax[tpu]==0.4.16" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html'
   

4. Scarica il repository HuggingFace e requisiti di installazione.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='git clone https://github.com/RissyRan/diffusers.git && cd diffusers && pip install . && pip install tensorflow==2.16.1 clu && pip install -U -r examples/text_to_image/requirements_flax.txt'
   

Addestra il modello

Addestra il modello con un buffer pre-mappato a 4 GB.

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='cd diffusers/examples/text_to_image && JAX_PLATFORMS=tpu,cpu python3 train_text_to_image_flax.py --pretrained_model_name_or_path=duongna/stable-diffusion-v1-4-flax --dataset_name=lambdalabs/pokemon-blip-captions --resolution=128 --center_crop --random_flip --train_batch_size=4 --mixed_precision=fp16 --max_train_steps=1500 --learning_rate=1e-05 --max_grad_norm=1 --output_dir=sd-pokemon-model'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Risultati del benchmarking per la diffusione

Lo script di addestramento veniva eseguito su v5litepod-4, v5litepod-16 e v5litepod-64. La tabella seguente mostra le velocità effettiva.

Tipo di acceleratore	V5litepod-4	V5litepod-16	V5litepod-64
Passaggio di addestramento	1500	1500	1500
Dimensione batch globale	32	64	128
Velocità effettiva (esempi/sec)	36,53	43,71	49,36

Addestrare GPT2 in base al set di dati OSCAR

Questo tutorial mostra come addestrare il modello GPT2 da HuggingFace utilizzando il set di dati OSCAR su Cloud TPU v5e.

GPT2 è un modello Transformer preaddestrato su testo non elaborato senza con l'etichettatura umana. È stato addestrato a prevedere la parola successiva nelle frasi. Per maggiori informazioni, consulta le seguenti risorse:

• Panoramica di GPT2
• Sorgente di codice GPT2

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=your_tpu_name
   export QUEUED_RESOURCE_ID=queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU una volta che la risorsa in coda è nello stato ACTIVE:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando la risorsa in coda è nello stato ACTIVE, l'output sarà simile a:

    state: ACTIVE
   

3. Installa JAX e la relativa libreria.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='pip install "jax[tpu]==0.4.16" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html'
   

4. Scarica il repository HuggingFace e requisiti di installazione.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='git clone https://github.com/huggingface/transformers.git && cd transformers && pip install . && pip install -r examples/flax/_tests_requirements.txt && pip install --upgrade huggingface-hub urllib3 zipp && pip install tensorflow && pip install -r examples/flax/language-modeling/requirements.txt'
   

5. Scaricare le configurazioni per addestrare il modello.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='cd transformers/examples/flax/language-modeling && gsutil cp -r gs://cloud-tpu-tpuvm-artifacts/v5litepod-preview/jax/gpt .'
   

Addestra il modello

Addestra il modello con un buffer pre-mappato a 4 GB.

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='cd transformers/examples/flax/language-modeling && TPU_PREMAPPED_BUFFER_SIZE=4294967296 JAX_PLATFORMS=tpu python3 run_clm_flax.py --output_dir=./gpt --model_type=gpt2 --config_name=./gpt --tokenizer_name=./gpt --dataset_name=oscar --dataset_config_name=unshuffled_deduplicated_no --do_train --do_eval --block_size=512 --per_device_train_batch_size=4 --per_device_eval_batch_size=4 --learning_rate=5e-3 --warmup_steps=1000 --adam_beta1=0.9 --adam_beta2=0.98 --weight_decay=0.01 --overwrite_output_dir --num_train_epochs=3 --logging_steps=500 --eval_steps=2500'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Risultati del benchmarking per GPT2

Lo script di addestramento veniva eseguito su v5litepod-4, v5litepod-16 e v5litepod-64. La tabella seguente mostra le velocità effettiva.

	V5litepod-4	V5litepod-16	V5litepod-64
Epoca	3	3	3
Dimensione batch globale	64	64	64
Velocità effettiva (esempi/sec)	74,60	72,97	72,62

PyTorch/XLA

Le seguenti sezioni descrivono esempi di come addestrare modelli PyTorch/XLA su TPU v5e.

Addestramento di ResNet mediante il runtime PJRT

PyTorch/XLA sta migrando da XRT a PjRt da PyTorch 2.0+. Ecco i tipi di Istruzioni aggiornate per configurare la versione 5e per i carichi di lavoro di addestramento PyTorch/XLA.

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=tpu-name
   export QUEUED_RESOURCE_ID=queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --{QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU una volta che la risorsa QueuedResource è nello stato ACTIVE:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando la risorsa in coda si trova nello stato ACTIVE, l'output sarà simile al seguente:

    state: ACTIVE
   

3. Installa le dipendenze specifiche di Torch/XLA

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='
         sudo apt-get update -y
         sudo apt-get install libomp5 -y
         pip3 install mkl mkl-include
         pip3 install tf-nightly tb-nightly tbp-nightly
         pip3 install numpy
         sudo apt-get install libopenblas-dev -y
         pip3 install torch~=2.1.0 torchvision torch_xla[tpu]~=2.1.0 -f https://storage.googleapis.com/libtpu-releases/index.html
         pip3 install torch_xla[tpu] -f https://storage.googleapis.com/libtpu-releases/index.html'
   

Addestra il modello ResNet

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='
      date
      export PJRT_DEVICE=TPU_C_API
      export PT_XLA_DEBUG=0
      export USE_TORCH=ON
      export XLA_USE_BF16=1
      export LIBTPU_INIT_ARGS=--xla_jf_auto_cross_replica_sharding
      export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
      export TPU_LIBRARY_PATH=$HOME/.local/lib/python3.10/site-packages/libtpu/libtpu.so
      git clone https://github.com/pytorch/xla.git
      cd xla/
      git reset --hard caf5168785c081cd7eb60b49fe4fffeb894c39d9
      python3 test/test_train_mp_imagenet.py --model=resnet50  --fake_data --num_epochs=1 —num_workers=16  --log_steps=300 --batch_size=64 --profile'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Risultato benchmark

La tabella seguente mostra le velocità effettiva benchmark.

Tipo di acceleratore	Velocità effettiva (esempi/secondo)
V5litepod-4	4240 ex/s
V5litepod-16	10.810 ex/s
V5litepod-64	46.154 ex/s

Addestrare GPT2 su v5e

Questo tutorial illustra come eseguire GPT2 su v5e utilizzando il repository HuggingFace su PyTorch/XLA utilizzando il set di dati wikitext

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=your_tpu_name
   export QUEUED_RESOURCE_ID=queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU una volta che QueuedResource Stato ACTIVE:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando la risorsa in coda si trova nello stato ACTIVE, l'output sarà simile al seguente:

   state: ACTIVE
   

3. Installa le dipendenze PyTorch/XLA.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='
         sudo apt-get -y update
         sudo apt install -y libopenblas-base
         pip3 install torchvision
         pip3 uninstall -y torch
         pip3 install torch~=2.1.0 torchvision torch_xla[tpu]~=2.1.0 -f https://storage.googleapis.com/libtpu-releases/index.html
         pip3 install torch_xla[tpu] -f https://storage.googleapis.com/libtpu-releases/index.html'
   

4. Scarica il repository HuggingFace e requisiti di installazione.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='
         git clone https://github.com/pytorch/xla.git
         pip install --upgrade accelerate
         git clone https://github.com/huggingface/transformers.git
         cd transformers
         git checkout ebdb185befaa821304d461ed6aa20a17e4dc3aa2
         pip install .
         git log -1
         pip install datasets evaluate scikit-learn
         '
   

5. Scarica le configurazioni del modello preaddestrato.

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command='
         gsutil cp -r gs://cloud-tpu-tpuvm-artifacts/config/xl-ml-test/pytorch/gpt2/my_config_2.json transformers/examples/pytorch/language-modeling/
         gsutil cp gs://cloud-tpu-tpuvm-artifacts/config/xl-ml-test/pytorch/gpt2/fsdp_config.json transformers/examples/pytorch/language-modeling/'
   

Addestra il modello

Addestra il modello 2B utilizzando una dimensione del batch di 16.

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='
      export PJRT_DEVICE=TPU_C_API
      cd transformers/
      export LD_LIBRARY_PATH=/usr/local/lib/
      export PT_XLA_DEBUG=0
      export USE_TORCH=ON
      python3 examples/pytorch/xla_spawn.py \
         --num_cores=4 \
         examples/pytorch/language-modeling/run_clm.py \
         --num_train_epochs=3 \
         --dataset_name=wikitext \
         --dataset_config_name=wikitext-2-raw-v1 \
         --per_device_train_batch_size=16 \
         --per_device_eval_batch_size=16 \
         --do_train \
         --do_eval \
         --logging_dir=./tensorboard-metrics \
         --cache_dir=./cache_dir \
         --output_dir=/tmp/test-clm \
         --overwrite_output_dir \
         --cache_dir=/tmp \
         --config_name=examples/pytorch/language-modeling/my_config_2.json \
         --tokenizer_name=gpt2 \
         --block_size=1024 \
         --optim=adafactor \
         --adafactor=true \
         --save_strategy=no \
         --logging_strategy=no \
         --fsdp=full_shard \
         --fsdp_config=examples/pytorch/language-modeling/fsdp_config.json'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --quiet

Risultato benchmark

Lo script di addestramento veniva eseguito su v5litepod-4, v5litepod-16 e v5litepod-64. La la seguente tabella mostra le velocità effettiva di benchmark per i diversi tipi di acceleratori.

	V5litepod-4	V5litepod-16	V5litepod-64
Epoca	3	3	3
config	600 mln	2 Mld	16 MLD
Dimensione batch globale	64	128	256
Velocità effettiva (esempi/sec)	66	77	31

Addestra ViT su v5e

Questo tutorial illustra come eseguire VIT su v5e utilizzando il repository HuggingFace su PyTorch/XLA sul set di dati cifar10.

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-west4-a
   export RUNTIME_VERSION=v2-alpha-tpuv5-lite
   export SERVICE_ACCOUNT=your_service_account
   export TPU_NAME=tpu-name
   export QUEUED_RESOURCE_ID=queued_resource_id
   export QUOTA_TYPE=quota_type
   export VALID_UNTIL_DURATION=1d
   

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --valid-until-duration=${VALID_UNTIL_DURATION} \
      --service-account=${SERVICE_ACCOUNT} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU una volta che QueuedResource lo stato ACTIVE:

    gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

   Quando la risorsa in coda si trova nello stato ACTIVE, l'output sarà simile al seguente:

    state: ACTIVE
   

3. Installa le dipendenze PyTorch/XLA

   gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all
      --command='
         sudo apt-get update -y
         sudo apt-get install libomp5 -y
         pip3 install mkl mkl-include
         pip3 install tf-nightly tb-nightly tbp-nightly
         pip3 install numpy
         sudo apt-get install libopenblas-dev -y
         pip3 install torch~=2.1.0 torchvision torch_xla[tpu]~=2.1.0 -f https://storage.googleapis.com/libtpu-releases/index.html
         pip3 install torch_xla[tpu] -f https://storage.googleapis.com/libtpu-releases/index.html'
   

4. Scarica il repository HuggingFace e requisiti di installazione.

      gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --worker=all \
      --command="
         git clone https://github.com/suexu1025/transformers.git vittransformers; \
         cd vittransformers; \
         pip3 install .; \
         pip3 install datasets; \
         wget https://github.com/pytorch/xla/blob/master/scripts/capture_profile.py"
   

Addestra il modello

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
   --project=${PROJECT_ID} \
   --zone=${ZONE} \
   --worker=all \
   --command='
      export PJRT_DEVICE=TPU_C_API
      export PT_XLA_DEBUG=0
      export USE_TORCH=ON
      export TF_CPP_MIN_LOG_LEVEL=0
      export XLA_USE_BF16=1
      export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
      export TPU_LIBRARY_PATH=$HOME/.local/lib/python3.10/site-packages/libtpu/libtpu.so
      cd vittransformers
      python3 -u examples/pytorch/xla_spawn.py --num_cores 4 examples/pytorch/image-pretraining/run_mae.py --dataset_name=cifar10 \
      --remove_unused_columns=False \
      --label_names=pixel_values \
      --mask_ratio=0.75 \
      --norm_pix_loss=True \
      --do_train=true \
      --do_eval=true \
      --base_learning_rate=1.5e-4 \
      --lr_scheduler_type=cosine \
      --weight_decay=0.05 \
      --num_train_epochs=3 \
      --warmup_ratio=0.05 \
      --per_device_train_batch_size=8 \
      --per_device_eval_batch_size=8 \
      --logging_strategy=steps \
      --logging_steps=30 \
      --evaluation_strategy=epoch \
      --save_strategy=epoch \
      --load_best_model_at_end=True \
      --save_total_limit=3 \
      --seed=1337 \
      --output_dir=MAE \
      --overwrite_output_dir=true \
      --logging_dir=./tensorboard-metrics \
      --tpu_metrics_debug=true'

Elimina la TPU e la risorsa in coda

Elimina la TPU e la risorsa in coda al termine della sessione.

gcloud compute tpus tpu-vm delete ${TPU_NAME}
   --project=${PROJECT_ID}
   --zone=${ZONE}
   --quiet

gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID}
   --project=${PROJECT_ID}
   --zone=${ZONE}
   --quiet

Risultato benchmark

La tabella seguente mostra le velocità effettiva di benchmark per i diversi tipi di acceleratori.

	V5litepod-4	V5litepod-16	V5litepod-64
Epoca	3	3	3
Dimensione batch globale	32	128	512
Velocità effettiva (esempi/sec)	201	657	2.844

TensorFlow 2.x

Le seguenti sezioni descrivono esempi di come addestrare TensorFlow 2.x su TPU v5e.

Addestramento di Resnet su un v5e a host singolo

Questo tutorial descrive come addestrare ImageNet su v5litepod-4 o v5litepod-8 utilizzando un set di dati falso. Per utilizzare un set di dati diverso, consulta Preparazione del set di dati.

Configura

1. Crea le variabili di ambiente:

   export PROJECT_ID=your-project-ID
   export ACCELERATOR_TYPE=v5litepod-4
   export ZONE=us-east1-c
   export RUNTIME_VERSION=tpu-vm-tf-2.15.0-pjrt
   export TPU_NAME=your-tpu-name
   export QUEUED_RESOURCE_ID=your-queued-resource-id
   export QUOTA_TYPE=quota-type
   

   ACCELERATOR_TYPE può essere v5litepod-4 o v5litepod-8.

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU quando la risorsa in coda si trova lo stato ACTIVE. Per controllare lo stato della risorsa in coda: utilizza questo comando:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

3. Connettiti alla TPU tramite SSH

   gcloud compute tpus tpu-vm ssh ${TPU_NAME}  \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

4. Imposta alcune variabili di ambiente

   export MODELS_REPO=/usr/share/tpu/models
   export PYTHONPATH="${MODELS_REPO}:${PYTHONPATH}"
   export MODEL_DIR=gcp-directory-to-store-model
   export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
   export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
   export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
   

5. Modifica la directory del repository dei modelli e installa i requisiti.

   cd ${MODELS_REPO} && git checkout r2.15.0
   pip install -r official/requirements.txt
   

Addestra il modello

Esegui lo script di addestramento.

python3 official/vision/train.py \
   --tpu=local \
   --experiment=resnet_imagenet \
   --mode=train_and_eval \
   --config_file=official/vision/configs/experiments/image_classification/imagenet_resnet50_tpu.yaml \
   --model_dir=${MODEL_DIR} \
   --params_override="runtime.distribution_strategy=tpu,task.train_data.input_path=${DATA_DIR}/train*,task.validation_data.input_path=${DATA_DIR}/validation*,task.train_data.global_batch_size=2048,task.validation_data.global_batch_size=2048,trainer.train_steps=100"

Elimina la TPU e la risorsa in coda

1. Elimina la tua TPU

   gcloud compute tpus tpu-vm delete ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --quiet
   

2. Elimina la richiesta di risorse in coda

   gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --quiet
   

Addestramento di Resnet su una v5e multi-host

Questo tutorial descrive come addestrare ImageNet su v5litepod-16 o più grandi utilizzando un falso set di dati. Se vuoi usare un set di dati diverso, consulta Preparazione del set di dati.

1. Crea le variabili di ambiente:

   export PROJECT_ID=your_project_ID
   export ACCELERATOR_TYPE=v5litepod-16
   export ZONE=us-east1-c
   export RUNTIME_VERSION=tpu-vm-tf-2.15.0-pod-pjrt
   export TPU_NAME=your_tpu_name
   export QUEUED_RESOURCE_ID=your-queued-resource-id
   export QUOTA_TYPE=quota-type
   

   Il valore di ACCELERATOR_TYPE può essere v5litepod-16 o superiore.

2. Crea una risorsa TPU:

   gcloud alpha compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
      --node-id=${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --accelerator-type=${ACCELERATOR_TYPE} \
      --runtime-version=${RUNTIME_VERSION} \
      --${QUOTA_TYPE}
   

   Nota: il flag QUOTA_TYPE può essere reserved o best-effort. Se nessuna di queste opzioni è specificata, il valore predefinito è on-demand. Vedi quotas per informazioni sui diversi tipi di quote supportati da Cloud TPU.

   Potrai accedere tramite SSH alla VM TPU quando la risorsa in coda si trova lo stato ACTIVE. Per controllare lo stato della risorsa in coda, utilizza seguente comando:

   gcloud compute tpus queued-resources describe ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

3. Connettiti alla TPU (worker zero) tramite SSH

   gcloud compute tpus tpu-vm ssh ${TPU_NAME}  \
      --project=${PROJECT_ID} \
      --zone=${ZONE}
   

4. Imposta alcune variabili di ambiente

   export MODELS_REPO=/usr/share/tpu/models
   export PYTHONPATH="${MODELS_REPO}:${PYTHONPATH}"
   export MODEL_DIR=gcp-directory-to-store-model
   export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
   export TPU_LOAD_LIBRARY=0
   export TPU_NAME=your_tpu_name
   

5. Modifica la directory del repository dei modelli e installa i requisiti.

    cd $MODELS_REPO && git checkout r2.15.0
    pip install -r official/requirements.txt
   

Addestra il modello

Esegui lo script di addestramento.

python3 official/vision/train.py \
   --tpu=${TPU_NAME} \
   --experiment=resnet_imagenet \
   --mode=train_and_eval \
   --model_dir=${MODEL_DIR} \
   --params_override="runtime.distribution_strategy=tpu,task.train_data.input_path=${DATA_DIR}/train*, task.validation_data.input_path=${DATA_DIR}/validation*"

Elimina la TPU e la risorsa in coda

1. Elimina la tua TPU

   gcloud compute tpus tpu-vm delete ${TPU_NAME} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --quiet
   

2. Elimina la richiesta di risorse in coda

   gcloud compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \
      --project=${PROJECT_ID} \
      --zone=${ZONE} \
      --quiet