1. Panoramica
In questo lab utilizzerai Vertex AI per eseguire un job di addestramento con più worker per un modello TensorFlow.
Cosa imparerai
Al termine del corso sarai in grado di:
- Modificare il codice dell'applicazione di addestramento per l'addestramento con più worker
- Configurare e avviare un job di addestramento multi-worker dall'interfaccia utente di Vertex AI
- Configura e avvia un job di addestramento per più worker con l'SDK Vertex
Il costo totale per l'esecuzione di questo lab su Google Cloud è di circa 5$.
2. Introduzione a Vertex AI
Questo lab utilizza la più recente offerta di prodotti AI disponibile su Google Cloud. Vertex AI integra le offerte ML di Google Cloud in un'esperienza di sviluppo fluida. In precedenza, i modelli addestrati con AutoML e i modelli personalizzati erano accessibili tramite servizi separati. La nuova offerta combina entrambi in un'unica API, insieme ad altri nuovi prodotti. Puoi anche migrare progetti esistenti su Vertex AI. In caso di feedback, consulta la pagina di supporto.
Vertex AI include molti prodotti diversi per supportare i flussi di lavoro ML end-to-end. Questo lab si concentrerà sui prodotti evidenziati di seguito: Training e Workbench
3. Panoramica del caso d'uso
In questo lab utilizzerai il trasferimento di apprendimento per addestrare un modello di classificazione delle immagini sul set di dati di manioca di TensorFlow Datasets. L'architettura che utilizzerai è un modello ResNet50 della libreria tf.keras.applications preaddestrato sul set di dati ImageNet.
Perché addestramento distribuito?
Se disponi di una singola GPU, TensorFlow utilizzerà questo acceleratore per accelerare l'addestramento del modello senza alcun intervento aggiuntivo da parte tua. Tuttavia, se vuoi ottimizzare l'utilizzo di più GPU su una singola macchina o su più macchine (ognuna con potenzialmente più GPU), dovrai utilizzare tf.distribute, la libreria di TensorFlow per eseguire un calcolo su più dispositivi. Un dispositivo si riferisce a una CPU o un acceleratore, come GPU o TPU, su una macchina su cui TensorFlow può eseguire operazioni.
Il modo più semplice per iniziare con l'addestramento distribuito è una singola macchina con più dispositivi GPU. Una strategia di distribuzione di TensorFlow del modulo tf.distribute gestirà il coordinamento della distribuzione dei dati e degli aggiornamenti del gradiente su tutte le GPU. Se hai già completato l'addestramento con un singolo host e vuoi aumentare ulteriormente le dimensioni, l'aggiunta di più macchine al cluster può aiutarti a ottenere un ulteriore miglioramento del rendimento. Puoi utilizzare un cluster di macchine che sono solo CPU o che hanno ciascuna una o più GPU. Questo lab illustra quest'ultimo caso e mostra come utilizzare MultiWorkerMirroredStrategy per distribuire l'addestramento di un modello TensorFlow su più macchine su Vertex AI.
MultiWorkerMirroredStrategy è una strategia di parallelismo dei dati sincrona che puoi utilizzare con poche modifiche al codice. Viene creata una copia del modello su ogni dispositivo nel cluster. Gli aggiornamenti successivi del gradiente verranno eseguiti in modo sincrono. Ciò significa che ciascun dispositivo worker calcola i passaggi avanti e indietro attraverso il modello su una sezione diversa dei dati di input. I gradienti calcolati da ciascuno di questi slice vengono poi aggregati su tutti i dispositivi di una macchina e su tutte le macchine del cluster e ridotti (di solito in media) in un processo noto come all-reduce. L'ottimizzatore esegue quindi gli aggiornamenti dei parametri con questi gradienti ridotti, mantenendo così i dispositivi sincronizzati. Per scoprire di più sull'addestramento distribuito con TensorFlow, guarda il video di seguito:
4. Configura l'ambiente
Per eseguire questo codelab, devi avere un progetto Google Cloud con la fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 1: abilita l'API Compute Engine
Vai a Compute Engine e seleziona Attiva se non è già abilitato. Ne avrai bisogno per creare la tua istanza di blocco note.
Passaggio 2: attiva l'API Container Registry
Vai a Container Registry e seleziona Attiva se non è già selezionato. Lo utilizzerai per creare un container per il tuo job di addestramento personalizzato.
Passaggio 3: attiva l'API Vertex AI
Vai alla sezione Vertex AI della console Cloud e fai clic su Abilita API Vertex AI.
Passaggio 4: crea un'istanza di Vertex AI Workbench
Nella sezione Vertex AI della console Cloud, fai clic su Workbench:
Se non l'hai ancora fatto, abilita l'API Notebooks.
Una volta attivata, fai clic su NOTEBOOK GESTORI:
Quindi seleziona NUOVO NOTEBOOK.
Assegna un nome al notebook e fai clic su Impostazioni avanzate.
In Impostazioni avanzate, attiva l'arresto in caso di inattività e imposta il numero di minuti su 60. Ciò significa che il notebook si spegnerà automaticamente quando non è in uso, in modo da non sostenere costi non necessari.
In Sicurezza, seleziona "Attiva terminale" se non è già abilitato.
Puoi lasciare invariate tutte le altre impostazioni avanzate.
Poi, fai clic su Crea. Il provisioning dell'istanza richiederà un paio di minuti.
Una volta creata l'istanza, seleziona Apri JupyterLab.
La prima volta che utilizzi una nuova istanza, ti verrà chiesto di autenticarti. Segui i passaggi nell'interfaccia utente.
5. containerizza il codice dell'applicazione di addestramento
Invierai questo job di addestramento a Vertex inserendo il codice dell'applicazione di addestramento in un container Docker ed eseguendo il push di questo container a Google Container Registry. Utilizzando questo approccio, puoi addestrare un modello creato con qualsiasi framework.
Per iniziare, apri una finestra del terminale nell'istanza del tuo blocco note dal menu Avvio app:
Crea una nuova directory denominata cassava e accedi tramite cd:
mkdir cassava
cd cassava
Passaggio 1: crea un Dockerfile
Il primo passaggio per containerizzare il codice è creare un Dockerfile. Nel Dockerfile includerai tutti i comandi necessari per eseguire l'immagine. Installerà tutte le librerie necessarie e configurerà il punto di accesso per il codice di addestramento.
Dal terminale, crea un Dockerfile vuoto:
touch Dockerfile
Apri il Dockerfile e copia al suo interno quanto segue:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-7
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]
Questo Dockerfile utilizza l'immagine Docker GPU TensorFlow Enterprise 2.7 del container di deep learning. Deep Learning Containers su Google Cloud è dotato di molti framework comuni di ML e data science preinstallati. Dopo aver scaricato l'immagine, questo Dockerfile configura il punto di accesso per il codice di addestramento. Non hai ancora creato questi file: nel passaggio successivo aggiungerai il codice per l'addestramento e la messa a punto del modello.
Passaggio 2: crea un bucket Cloud Storage
In questo job di addestramento, esporterai il modello TensorFlow addestrato in un bucket Cloud Storage. Dal tuo terminale, esegui quanto segue per definire una variabile env per il tuo progetto, assicurandoti di sostituire your-cloud-project con l'ID del tuo progetto:
PROJECT_ID='your-cloud-project'
Quindi, esegui il comando seguente nel terminale per creare un nuovo bucket nel tuo progetto.
BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET
Passaggio 3: aggiungi il codice di addestramento del modello
Dal tuo terminale, esegui quanto segue per creare una directory per il codice di addestramento e un file Python in cui aggiungerai il codice:
mkdir trainer
touch trainer/task.py
Ora dovresti avere quanto segue nella directory cassava/:
+ Dockerfile
+ trainer/
+ task.py
Successivamente, apri il file task.py che hai appena creato e copia il codice seguente. Dovrai sostituire {your-gcs-bucket} con il nome del bucket Cloud Storage che hai appena creato.
import tensorflow as tf
import tensorflow_datasets as tfds
import os
PER_REPLICA_BATCH_SIZE = 64
EPOCHS = 2
# TODO: replace {your-gcs-bucket} with the name of the Storage bucket you created earlier
BUCKET = 'gs://{your-gcs-bucket}/mwms'
def preprocess_data(image, label):
'''Resizes and scales images.'''
image = tf.image.resize(image, (300,300))
return tf.cast(image, tf.float32) / 255., label
def create_dataset(batch_size):
'''Loads Cassava dataset and preprocesses data.'''
data, info = tfds.load(name='cassava', as_supervised=True, with_info=True)
number_of_classes = info.features['label'].num_classes
train_data = data['train'].map(preprocess_data,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
train_data = train_data.shuffle(1000)
train_data = train_data.batch(batch_size)
train_data = train_data.prefetch(tf.data.experimental.AUTOTUNE)
# Set AutoShardPolicy
options = tf.data.Options()
options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA
train_data = train_data.with_options(options)
return train_data, number_of_classes
def create_model(number_of_classes):
'''Creates and compiles pretrained ResNet50 model.'''
base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
x = base_model.output
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(1016, activation='relu')(x)
predictions = tf.keras.layers.Dense(number_of_classes, activation='softmax')(x)
model = tf.keras.Model(inputs=base_model.input, outputs=predictions)
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=tf.keras.optimizers.Adam(0.0001),
metrics=['accuracy'])
return model
def _is_chief(task_type, task_id):
'''Helper function. Determines if machine is chief.'''
return task_type == 'chief'
def _get_temp_dir(dirpath, task_id):
'''Helper function. Gets temporary directory for saving model.'''
base_dirpath = 'workertemp_' + str(task_id)
temp_dir = os.path.join(dirpath, base_dirpath)
tf.io.gfile.makedirs(temp_dir)
return temp_dir
def write_filepath(filepath, task_type, task_id):
'''Helper function. Gets filepath to save model.'''
dirpath = os.path.dirname(filepath)
base = os.path.basename(filepath)
if not _is_chief(task_type, task_id):
dirpath = _get_temp_dir(dirpath, task_id)
return os.path.join(dirpath, base)
def main():
# Create strategy
strategy = tf.distribute.MultiWorkerMirroredStrategy()
# Get data
global_batch_size = PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync
train_data, number_of_classes = create_dataset(global_batch_size)
# Wrap variable creation within strategy scope
with strategy.scope():
model = create_model(number_of_classes)
model.fit(train_data, epochs=EPOCHS)
# Determine type and task of the machine from
# the strategy cluster resolver
task_type, task_id = (strategy.cluster_resolver.task_type,
strategy.cluster_resolver.task_id)
# Based on the type and task, write to the desired model path
write_model_path = write_filepath(BUCKET, task_type, task_id)
model.save(write_model_path)
if __name__ == "__main__":
main()
Prima di creare il contenitore, diamo uno sguardo più approfondito al codice, che utilizza MultiWorkerMirroredStrategy dall'API tf.distribute.Strategy.
Il codice contiene alcuni componenti necessari per il suo funzionamento con MultiWorkerMirroredStrategy.
- I dati devono essere sottoposti a sharding, ovvero a ogni worker viene assegnato un sottoinsieme dell'intero set di dati. Pertanto, a ogni passaggio, ogni worker elaborerà un batch globale di elementi del set di dati non sovrapposti. Questo partizionamento orizzontale avviene automaticamente con
tf.data.experimental.AutoShardPolicy, che può essere impostato suFILEoDATA. In questo esempio, la funzionecreate_dataset()impostaAutoShardPolicysuDATAperché il set di dati di manioca non viene scaricato come più file. Tuttavia, se non imposti il criterio suDATA, verrà applicato il criterio predefinitoAUTOe il risultato finale sarà lo stesso. Scopri di più sullo sharding dei set di dati conMultiWorkerMirroredStrategyqui. - Nella funzione
main()viene creato l'oggettoMultiWorkerMirroredStrategy. Poi, inserisci la creazione delle variabili del modello nell'ambito della strategia. Questo passaggio fondamentale indica a TensorFlow quali variabili devono essere sottoposte a mirroring tra le repliche. - La dimensione del batch viene scalata dall'
num_replicas_in_sync. In questo modo, ogni replica elabora lo stesso numero di esempi in ogni passaggio. La scalabilità della dimensione del batch è una best practice quando si utilizzano strategie di parallelismo dei dati sincrono in TensorFlow. - Salvare il modello è leggermente più complicato nel caso con più worker perché la destinazione deve essere diversa per ogni worker. Il worker principale eseguirà il salvataggio nella directory del modello desiderata, mentre gli altri worker salveranno il modello in directory temporanee. È importante che queste directory temporanee siano univoche per impedire a più worker di scrivere nella stessa posizione. Il salvataggio può contenere operazioni collettive, il che significa che tutti i lavoratori devono salvare e non solo il capo. Le funzioni
_is_chief(),_get_temp_dir(),write_filepath()e la funzionemain()includono tutte il codice boilerplate che consente di salvare il modello.
Tieni presente che se hai utilizzato MultiWorkerMirroredStrategy in un altro ambiente, potresti aver configurato la variabile di ambiente TF_CONFIG. Vertex AI imposta automaticamente TF_CONFIG, quindi non devi definire questa variabile su ogni macchina del cluster.
Passaggio 4: crea il contenitore
Dal tuo terminale, esegui quanto segue per definire una variabile env per il tuo progetto, assicurandoti di sostituire your-cloud-project con l'ID del tuo progetto:
PROJECT_ID='your-cloud-project'
Definisci una variabile con l'URI dell'immagine container in Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/multiworker:cassava"
Configura Docker
gcloud auth configure-docker
Quindi, crea il container eseguendo quanto segue dalla radice della directory cassava:
docker build ./ -t $IMAGE_URI
Infine, invialo a Google Container Registry:
docker push $IMAGE_URI
Dopo il push del container in Container Registry, puoi avviare il job di addestramento.
6. Esegui un job di addestramento multi-worker su Vertex AI
Questo lab utilizza l'addestramento personalizzato tramite un container personalizzato su Google Container Registry, ma puoi anche eseguire un job di addestramento con i container predefiniti.
Per iniziare, vai alla sezione Addestramento nella sezione Vertex della console Cloud:
Passaggio 1: configura il job di addestramento
Fai clic su Crea per inserire i parametri per il job di addestramento.
- In Set di dati, seleziona Nessun set di dati gestito
- Quindi, seleziona Addestramento personalizzato (avanzato) come metodo di addestramento e fai clic su Continua.
- Inserisci
multiworker-cassava(o come preferisci chiamare il tuo modello) in Nome modello. - Fai clic su Continua.
Nel passaggio Impostazioni contenitore, seleziona Container personalizzato:
Nella prima casella (Immagine container), inserisci il valore della variabile IMAGE_URI della sezione precedente. Dovrebbe essere: gcr.io/your-cloud-project/multiworker:cassava, con il tuo ID progetto. Lascia vuoti gli altri campi e fai clic su Continua.
Ignora il passaggio sugli iperparametri facendo di nuovo clic su Continua.
Passaggio 2: configura il cluster di computing
Vertex AI fornisce 4 pool di worker per coprire i diversi tipi di attività delle macchine.
Pool di worker 0 configura il principale, principale, di pianificazione o "master". In MultiWorkerMirroredStrategy, tutte le macchine sono designate come worker, ovvero le macchine fisiche su cui viene eseguito il calcolo replicato. Oltre a essere un worker, ogni macchina deve avere un worker che si occupi di alcuni compiti aggiuntivi, come il salvataggio dei checkpoint e la scrittura di file di riepilogo in TensorBoard. Questa macchina è nota come chief. Esiste sempre un solo worker principale, pertanto il conteggio dei worker per il pool di worker 0 sarà sempre 1.
In Compute e prezzi, lascia la regione selezionata così com'è e configura Pool di worker 0 come segue:
Nel pool di worker 1 puoi configurare i worker per il cluster.
Configura Pool di worker 1 come segue:
Il cluster è ora configurato in modo da avere due macchine solo CPU. Quando viene eseguito il codice dell'applicazione di addestramento, MultiWorkerMirroredStrategy distribuisce l'addestramento su entrambe le macchine.
MultiWorkerMirroredStrategy ha solo i tipi di attività di capo e di worker, quindi non è necessario configurare i pool di worker aggiuntivi. Tuttavia, se utilizzi ParameterServerStrategy di TensorFlow, devi configurare i server di parametri nel pool di worker 2. Se volessi aggiungere un valutatore al cluster, devi configurare la macchina nel pool di worker 3.
Fai clic su Inizia addestramento per avviare il job di ottimizzazione degli iperparametri. Nella sezione Addestramento della console, nella scheda PIPELINE DI ADDESTRAMENTO vedrai il job appena lanciato:
🎉 Complimenti! 🎉
Hai imparato come utilizzare Vertex AI per:
- Avvia un job di addestramento multi-worker per il codice di addestramento fornito in un container personalizzato. In questo esempio hai utilizzato un modello TensorFlow, ma puoi addestrare un modello creato con qualsiasi framework utilizzando container personalizzati o integrati.
Per saperne di più sulle diverse parti di Vertex, consulta la documentazione.
7. [Facoltativo] Utilizza l'SDK Vertex
La sezione precedente ha mostrato come avviare il job di addestramento tramite l'interfaccia utente. In questa sezione viene illustrato un modo alternativo per inviare il job di addestramento mediante l'API Vertex Python.
Torna all'istanza del blocco note e crea un blocco note TensorFlow 2 dall'Avvio app:
Importa l'SDK Vertex AI.
from google.cloud import aiplatform
Per avviare il job di addestramento multi-worker, devi prima definire la specifica del pool di worker. Tieni presente che l'utilizzo delle GPU nella specifica è completamente facoltativo e puoi rimuovere accelerator_type e accelerator_count se vuoi un cluster solo CPU come mostrato nella sezione precedente.
# The spec of the worker pools including machine type and Docker image
# Be sure to replace {YOUR-PROJECT-ID} with your project ID.
worker_pool_specs=[
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
},
"container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
},
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
},
"container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
}
]
Poi, crea ed esegui un CustomJob. Dovrai sostituire {YOUR_BUCKET} con un bucket nel tuo progetto per l'implementazione. Puoi utilizzare lo stesso bucket creato in precedenza.
# Replace YOUR_BUCKET
my_multiworker_job = aiplatform.CustomJob(display_name='multiworker-cassava-sdk',
worker_pool_specs=worker_pool_specs,
staging_bucket='gs://{YOUR_BUCKET}')
my_multiworker_job.run()
Nella sezione Addestramento della console, nella scheda JOB PERSONALIZZATI vedrai il tuo job di addestramento:
8. Esegui la pulizia
Poiché abbiamo configurato il timeout del blocco note dopo 60 minuti di inattività, non dobbiamo preoccuparci di arrestare l'istanza. Se vuoi arrestare manualmente l'istanza, fai clic sul pulsante Interrompi nella sezione Vertex AI Workbench della console. Se vuoi eliminare completamente il blocco note, fai clic sul pulsante Elimina.
Per eliminare il bucket di archiviazione, utilizza il menu di navigazione nella console Cloud, vai su Storage, seleziona il bucket e fai clic su Elimina:
