Vertex AI: usa la pacchettizzazione automatica per ottimizzare BERT con Hugging Face su Vertex AI Training

1. Panoramica

In questo lab imparerai a eseguire un job di addestramento personalizzato in Vertex AI Training con la funzionalità di pacchettizzamento automatico. I job di addestramento personalizzati su Vertex AI utilizzano i container. Se non vuoi creare la tua immagine, puoi utilizzare l'auto-packaging, che creerà un'immagine Docker personalizzata in base al tuo codice, eseguirà il push dell'immagine in Container Registry e avvierà un CustomJob in base all'immagine.

Cosa imparerai

Al termine del corso sarai in grado di:

• Utilizza la modalità locale per testare il codice.
• Configura e avvia un job di addestramento personalizzato con il pacchettizzazione automatica.

Il costo totale per eseguire questo lab su Google Cloud è di circa 2$.

2. Panoramica del caso d'uso

Utilizzando le librerie di Hugging Face, perfezionerai un modello Bert sul set di dati IMDB. Il modello prevede se una recensione di un film è positiva o negativa. Il set di dati verrà scaricato dalla libreria dei set di dati di Hugging Face e il modello Bert dalla libreria dei trasformatori di Hugging Face.

3. 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à su Training e Workbench.

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.

Passaggio 2: abilita l'API Vertex AI

Vai alla sezione Vertex AI della console Cloud e fai clic su Abilita API Vertex AI.

Passaggio 3: attiva l'API Container Registry

Vai a Container Registry e seleziona Abilita, se non è già selezionato. Lo utilizzerai per creare un container per il tuo job di addestramento personalizzato.

Passaggio 4: crea un'istanza di Vertex AI Workbench

Nella sezione Vertex AI della console Cloud, fai clic su Workbench:

Quindi, fai clic su QUADRI GESTITI:

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.

Puoi lasciare invariate tutte le altre impostazioni avanzate.

Poi, fai clic su Crea.

Una volta creata l'istanza, seleziona Apri JupyterLab.

La prima volta che utilizzi una nuova istanza, ti verrà chiesto di autenticarti.

5. Scrivi il codice di addestramento

Per iniziare, apri una finestra del terminale nell'istanza del tuo blocco note dal menu Avvio app:

Crea una nuova directory chiamata autopkg-codelab e accedi con cd.

mkdir autopkg-codelab
cd autopkg-codelab

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 tua directory autopkg-codelab/:

+ trainer/
    + task.py

Successivamente, apri il file task.py che hai appena creato e copia il codice riportato di seguito.

import argparse

import tensorflow as tf
from datasets import load_dataset
from transformers import AutoTokenizer
from transformers import TFAutoModelForSequenceClassification

CHECKPOINT = "bert-base-cased"

def get_args():
  '''Parses args.'''

  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--epochs',
      required=False,
      default=3,
      type=int,
      help='number of epochs')
  parser.add_argument(
      '--job_dir',
      required=True,
      type=str,
      help='bucket to store saved model, include gs://')
  args = parser.parse_args()
  return args


def create_datasets():
    '''Creates a tf.data.Dataset for train and evaluation.'''

    raw_datasets = load_dataset('imdb')
    tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
    tokenized_datasets = raw_datasets.map((lambda examples: tokenize_function(examples, tokenizer)), batched=True)

    # To speed up training, we use only a portion of the data.
    # Use full_train_dataset and full_eval_dataset if you want to train on all the data.
    small_train_dataset = tokenized_datasets['train'].shuffle(seed=42).select(range(1000))
    small_eval_dataset = tokenized_datasets['test'].shuffle(seed=42).select(range(1000))
    full_train_dataset = tokenized_datasets['train']
    full_eval_dataset = tokenized_datasets['test']

    tf_train_dataset = small_train_dataset.remove_columns(['text']).with_format("tensorflow")
    tf_eval_dataset = small_eval_dataset.remove_columns(['text']).with_format("tensorflow")

    train_features = {x: tf_train_dataset[x] for x in tokenizer.model_input_names}
    train_tf_dataset = tf.data.Dataset.from_tensor_slices((train_features, tf_train_dataset["label"]))
    train_tf_dataset = train_tf_dataset.shuffle(len(tf_train_dataset)).batch(8)

    eval_features = {x: tf_eval_dataset[x] for x in tokenizer.model_input_names}
    eval_tf_dataset = tf.data.Dataset.from_tensor_slices((eval_features, tf_eval_dataset["label"]))
    eval_tf_dataset = eval_tf_dataset.batch(8)

    return train_tf_dataset, eval_tf_dataset


def tokenize_function(examples, tokenizer):
    '''Tokenizes text examples.'''

    return tokenizer(examples['text'], padding='max_length', truncation=True)


def main():
    args = get_args()
    train_tf_dataset, eval_tf_dataset = create_datasets()
    model = TFAutoModelForSequenceClassification.from_pretrained(CHECKPOINT, num_labels=2)

    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
        loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        metrics=tf.metrics.SparseCategoricalAccuracy(),
    )

    model.fit(train_tf_dataset, validation_data=eval_tf_dataset, epochs=args.epochs)
    model.save(f'{args.job_dir}/model_output')


if __name__ == "__main__":
    main()

Ecco alcuni aspetti da tenere presenti in merito al codice:

• CHECKPOINT è il modello che vogliamo ottimizzare. In questo caso, utilizziamo Bert.
• Il metodo TFAutoModelForSequenceClassification carica l'architettura del modello linguistico specificato e i relativi pesi in TensorFlow e aggiunge un'unità di classificazione con pesi inizializzati in modo casuale. In questo caso, abbiamo un problema di classificazione binaria (positivo o negativo), quindi specifichiamo num_labels=2 per questo classificatore.

6. Containerizzazione ed esecuzione del codice di addestramento a livello locale

Puoi utilizzare il comando gcloud ai custom-jobs local-run per creare un'immagine container Docker basata sul codice di addestramento ed eseguirla come container sulla macchina locale. L'esecuzione in locale di un container permette di eseguire il codice di addestramento in modo simile a come viene fatto su Vertex AI Training e può aiutarti a eseguire il debug dei problemi del codice prima di eseguire l'addestramento personalizzato in Vertex AI.

Nel nostro job di addestramento, esporteremo il modello 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:

Puoi ottenere l'ID progetto eseguendo gcloud config list --format 'value(core.project)' nel terminale

PROJECT_ID='your-cloud-project'

Poi, crea un bucket. Se hai già un bucket, utilizzalo.

BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME

Quando eseguiamo il job di addestramento personalizzato in Vertex AI Training, utilizzeremo una GPU. Tuttavia, poiché non abbiamo specificato la nostra istanza Workbench con GPU, utilizzeremo un'immagine basata su CPU per i test locali. In questo esempio utilizziamo un container predefinito di Vertex AI Training.

Esegui il seguente comando per impostare l'URI di un'immagine Docker da utilizzare come base del container.

BASE_CPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-7:latest

Poi imposta un nome per l'immagine Docker risultante creata dal comando di esecuzione locale.

OUTPUT_IMAGE=$PROJECT_ID-local-package-cpu:latest

Il nostro codice di addestramento utilizza i set di dati e le librerie di trasformatori di Hugging Face. Queste librerie non sono incluse nell'immagine che abbiamo selezionato come immagine di base, quindi dovremo fornirle come requisiti. Per farlo, creeremo un file requirements.txt nella directory autopkg-codelab.

Assicurati di essere nella directory autopkg-codelab e digita quanto segue nel terminale.

touch requirements.txt

Ora dovresti avere quanto segue nella tua directory autopkg-codelab:

+ requirements.txt
+ trainer/
    + task.py

Apri il file dei requisiti e incolla quanto segue

datasets==1.18.2
transformers==4.16.2

Infine, esegui il comando gcloud ai custom-jobs local-run per avviare l'addestramento nella nostra istanza gestita di Workbench.

gcloud ai custom-jobs local-run \
--executor-image-uri=$BASE_CPU_IMAGE \
--python-module=trainer.task \
--output-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME

Dovresti vedere l'immagine Docker in fase di creazione. Le dipendenze che abbiamo aggiunto al file requirements.txt verranno installate con pip. La prima volta che esegui questo comando, l'operazione potrebbe richiedere alcuni minuti. Una volta creata l'immagine, il filetask.py inizierà a essere eseguito e vedrai l'addestramento del modello. Il risultato dovrebbe essere simile a questo:

Poiché non utilizziamo una GPU localmente, l'addestramento del modello richiederà molto tempo. Puoi premere Ctrl+C e annullare l'addestramento locale anziché attendere il completamento del job.

Tieni presente che, se vuoi eseguire ulteriori test, puoi anche eseguire direttamente l'immagine creata sopra, senza eseguire il nuovo pacchettizzazione.

gcloud beta ai custom-jobs local-run \
--executor-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME \
--epochs=1

7. Creazione di un job personalizzato

Ora che abbiamo testato la modalità locale, utilizzeremo la funzionalità di pacchettizzamento automatico per lanciare il nostro job di addestramento personalizzato in Vertex AI Training. Con un solo comando, questa funzionalità:

• Crea un'immagine Docker personalizzata basata sul tuo codice.
• Esegui il push dell'immagine in Container Registry.
• Avvia un CustomJob basato sull'immagine.

Torna al terminale ed esegui cd un livello sopra la directory autopkg-codelab.

+ autopkg-codelab
  + requirements.txt
  + trainer/
      + task.py

Specifica l'immagine GPU TensorFlow predefinita di Vertex AI Training come immagine di base per il job di addestramento personalizzato.

BASE_GPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-gpu.2-7:latest

Quindi, esegui il comando gcloud ai custom-jobs create. Innanzitutto, questo comando creerà un'immagine Docker personalizzata in base al codice di addestramento. L'immagine di base è il container predefinito di Vertex AI Training impostato come BASE_GPU_IMAGE. La funzionalità di imballaggio automatico installerà quindi i set di dati e le librerie di trasformatori come specificato nel file requirements.txt.

gcloud ai custom-jobs create \
--region=us-central1 \
--display-name=fine_tune_bert \
--args=--job_dir=$BUCKET_NAME \
--worker-pool-spec=machine-type=n1-standard-4,replica-count=1,accelerator-type=NVIDIA_TESLA_V100,executor-image-uri=$BASE_GPU_IMAGE,local-package-path=autopkg-codelab,python-module=trainer.task

Diamo un'occhiata all'argomento worker-pool-spec. Viene definita la configurazione del pool di worker utilizzata dal job personalizzato. Puoi specificare più specifiche del pool di worker per creare un job personalizzato con più pool di worker per l'addestramento distribuito. In questo esempio, specifichiamo un solo pool di worker, poiché il codice di addestramento non è configurato per l'addestramento distribuito.

Ecco alcuni dei campi principali di questa specifica:

• machine-type (obbligatorio): il tipo di macchina. Fai clic qui per visualizzare i tipi supportati.
• replica-count: il numero di repliche di worker da utilizzare per questo pool di worker. Per impostazione predefinita, il valore è 1.
• accelerator-type: il tipo di GPU. Fai clic qui per conoscere i tipi supportati. In questo esempio, abbiamo specificato una GPU NVIDIA Tesla V100.
• accelerator-count: il numero di GPU da utilizzare per ogni VM nel pool di worker. Per impostazione predefinita, il valore è 1.
• executor-image-uri: l'URI di un'immagine del container che eseguirà il pacchetto fornito. È impostato sulla nostra immagine di base.
• local-package-path: il percorso locale di una cartella contenente il codice di addestramento.
• python-module: il nome del modulo Python da eseguire all'interno del pacchetto fornito.

Analogamente a quando hai eseguito il comando locale, vedrai l'immagine Docker in fase di creazione e il job di addestramento verrà avviato. Tranne invece di vedere l'output del job di addestramento, vedrai il seguente messaggio che conferma l'avvio del job di addestramento. Tieni presente che la prima volta che esegui il comando custom-jobs create, la compilazione e il push dell'immagine potrebbero richiedere alcuni minuti.

Torna alla sezione Addestramento di Vertex AI della console Cloud e in JOB PERSONALIZZATI dovresti vedere il tuo job in esecuzione.

Il completamento del job richiederà circa 20 minuti.

Al termine, dovresti visualizzare i seguenti elementi del modello salvati nella directory model_output del bucket.

🎉 Complimenti! 🎉

Hai imparato come utilizzare Vertex AI per:

• Containerizzazione ed esecuzione del codice di addestramento a livello locale
• Inviare job di addestramento a Vertex AI Training con il pacchettizzazione automatica

Per scoprire di più sulle diverse parti di Vertex AI, consulta la documentazione.

8. Esegui la pulizia

Poiché abbiamo configurato il notebook in modo che termini il timeout 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 a Archiviazione, seleziona il bucket e fai clic su Elimina: