1. Panoramica
In questo lab utilizzerai Vertex AI per addestrare e pubblicare un modello TensorFlow utilizzando il codice in un contenitore personalizzato.
Sebbene in questo caso utilizziamo TensorFlow per il codice del modello, potresti facilmente sostituirlo con un altro framework.
Cosa imparerai
Al termine del corso sarai in grado di:
- Crea e containerizza il codice di addestramento del modello in Vertex Workbench
- Invia un job di addestramento di modelli personalizzati a Vertex AI
- Esegui il deployment del modello addestrato in un endpoint e utilizza l'endpoint per ottenere le previsioni
Il costo totale per eseguire questo lab su Google Cloud è di circa 1$.
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: addestramento, previsione e Workbench.
3. Configura l'ambiente
Per eseguire questo codelab, è necessario un progetto Google Cloud con fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 1: abilita l'API Compute Engine
Passa a Compute Engine e seleziona Abilita se non è già abilitato. Ne avrai bisogno per creare la tua istanza di blocco note.
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 Attiva 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:
Da qui, fai clic su Nuovo blocco note in Blocchi note gestiti dall'utente:
Quindi, seleziona la versione più recente del tipo di istanza TensorFlow Enterprise (con LTS) senza GPU:
Utilizza le opzioni predefinite e fai clic su Crea.
Il modello che addestreremo e pubblicheremo in questo lab è basato su questo tutorial delle documentazioni di TensorFlow. Il tutorial utilizza il set di dati Auto MPG di Kaggle per prevedere il consumo di carburante di un veicolo.
4. Containerizza il codice di addestramento
Invieremo questo job di addestramento a Vertex inserendo il codice di addestramento in un container Docker ed eseguendo il push di questo container in Google Container Registry. Con questo approccio possiamo 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 mpg e accedi tramite cd:
mkdir mpg
cd mpg
Passaggio 1: crea un Dockerfile
Il primo passaggio per containerizzare il codice è creare un Dockerfile. Nel nostro Dockerfile includeremo tutti i comandi necessari per eseguire l'immagine. Installerà tutte le librerie che utilizziamo e configurerà il punto di accesso per il nostro 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-cpu.2-6
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.train"]
Questo Dockerfile utilizza l'immagine Docker del container di deep learning TensorFlow Enterprise 2.3. Deep Learning Containers su Google Cloud è dotato di molti framework comuni di ML e data science preinstallati. Quello che utilizziamo include TF Enterprise 2.3, Pandas, Scikit-learn e altri. Dopo aver scaricato l'immagine, questo Dockerfile configura il punto di accesso per il nostro codice di addestramento. Non abbiamo ancora creato questi file: nel passaggio successivo aggiungeremo il codice per l'addestramento ed l'esportazione del modello.
Passaggio 2: crea un bucket Cloud Storage
Nel nostro job di addestramento, esporteremo il modello TensorFlow addestrato in un bucket Cloud Storage. Vertex lo utilizzerà per leggere gli asset del modello esportati ed eseguirne il deployment. 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'
Successivamente, esegui il seguente comando nel terminale per creare un nuovo bucket nel progetto. Il flag -l (location) è importante perché deve trovarsi nella stessa regione in cui esegui il deployment di un endpoint del modello più avanti nel tutorial:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
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/train.py
Ora dovresti avere quanto segue nella directory mpg/:
+ Dockerfile
+ trainer/
+ train.py
Successivamente, apri il file train.py che hai appena creato e copia il codice riportato di seguito (adattato dal tutorial nelle documentazioni di TensorFlow).
All'inizio del file, aggiorna la variabile BUCKET con il nome del bucket di archiviazione creato nel passaggio precedente:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
Passaggio 4: crea e testa il contenitore in locale
Da Terminal, definisci una variabile con l'URI dell'immagine container in Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Quindi, crea il container eseguendo quanto segue dalla radice della directory mpg:
docker build ./ -t $IMAGE_URI
Esegui il container all'interno dell'istanza del blocco note per assicurarti che funzioni correttamente:
docker run $IMAGE_URI
L'addestramento del modello dovrebbe terminare in 1-2 minuti con un'accuratezza di convalida di circa il 72% (l'accuratezza esatta può variare). Dopo aver eseguito il container in locale, esegui il push in Google Container Registry:
docker push $IMAGE_URI
Dopo aver eseguito il push del container in Container Registry, ora possiamo avviare un job di addestramento del modello personalizzato.
5. Esegui un job di addestramento su Vertex AI
Vertex AI offre due opzioni per l'addestramento dei modelli:
- AutoML: addestrare modelli di alta qualità con il minimo sforzo e senza dover avere esperienza nel machine learning.
- Addestramento personalizzato: esegui le tue applicazioni di addestramento personalizzato nel cloud utilizzando uno dei container predefiniti di Google Cloud o utilizzane uno tuo.
In questo lab utilizziamo l'addestramento personalizzato tramite il nostro container personalizzato su Google Container Registry. Per iniziare, vai alla sezione Modelli nella sezione Vertex della console Cloud:
Passaggio 1: avvia il job di addestramento
Fai clic su Crea per inserire i parametri per il job di addestramento e il modello di cui è stato eseguito il deployment:
- In Set di dati, seleziona Nessun set di dati gestito.
- Quindi seleziona Addestramento personalizzato (avanzato) come metodo di addestramento e fai clic su Continua.
- Fai clic su Continua.
Nel passaggio successivo, inserisci mpg (o come preferisci chiamare il tuo modello) in Nome modello. Quindi, seleziona Container personalizzato:
Nella casella di testo Immagine container, fai clic su Sfoglia e trova l'immagine Docker appena caricata in Container Registry. Lascia vuoti gli altri campi e fai clic su Continua.
In questo tutorial non utilizzeremo l'ottimizzazione degli iperparametri, quindi lascia deselezionata la casella Abilita ottimizzazione degli iperparametri e fai clic su Continua.
In Compute e prezzi, lascia invariata la regione selezionata e scegli n1-standard-4 come tipo di macchina:
Lascia vuoti i campi dell'acceleratore e seleziona Continua. Poiché il modello in questa demo viene addestrato rapidamente, utilizziamo un tipo di macchina più piccolo.
Nel passaggio Container di previsione, seleziona Container predefinito e poi TensorFlow 2.6.
Lascia invariate le impostazioni predefinite per il contenitore predefinito. In Model directory (Directory del modello), inserisci il bucket GCS con la sottodirectory mpg. Questo è il percorso nello script di addestramento del modello in cui esporti il modello addestrato:
Vertex cercherà in questa posizione quando eseguirà il deployment del modello. Ora è tutto pronto per l'addestramento. Fai clic su Inizia addestramento per avviare il job di addestramento. Nella sezione Addestramento della tua console, vedrai qualcosa di simile a questo:
6. Eseguire il deployment di un endpoint del modello
Quando abbiamo configurato il job di addestramento, abbiamo specificato dove Vertex AI deve cercare gli asset del modello esportati. Nell'ambito della nostra pipeline di addestramento, Vertex creerà una risorsa modello in base a questo percorso dell'asset. La risorsa del modello non è un modello di cui è stato eseguito il deployment, ma una volta creato un modello, puoi eseguirne il deployment in un endpoint. Per scoprire di più su Modelli ed endpoint in Vertex AI, consulta la documentazione.
In questo passaggio creeremo un endpoint per il nostro modello addestrato. Possiamo utilizzarlo per ottenere previsioni sul nostro modello tramite l'API Vertex AI.
Passaggio 1: esegui il deployment dell'endpoint
Al termine del job di addestramento, nella sezione Modelli della console dovresti vedere un modello denominato mpg (o come lo hai chiamato):
Quando è stato eseguito il job di addestramento, Vertex ha creato una risorsa modello per te. Per utilizzare questo modello, devi eseguire il deployment di un endpoint. Puoi avere molti endpoint per modello. Fai clic sul modello e poi su Esegui il deployment nell'endpoint.
Seleziona Crea nuovo endpoint e assegnagli un nome, ad esempio v1. Lascia selezionata l'opzione Standard per Access e fai clic su Continua.
Lascia Suddivisione traffico su 100 e inserisci 1 per Numero minimo di nodi di calcolo. In Tipo di macchina, seleziona n1-standard-2 (o qualsiasi altro tipo di macchina che preferisci). Lascia selezionate le altre impostazioni predefinite e fai clic su Continua. Non abiliteremo il monitoraggio per questo modello, quindi fai clic su Esegui il deployment per avviare il deployment dell'endpoint.
Il deployment dell'endpoint richiederà 10-15 minuti e riceverai un'email al termine dell'operazione. Al termine del deployment dell'endpoint, viene visualizzato quanto segue, che mostra un endpoint di cui è stato eseguito il deployment nella risorsa Model:
Passaggio 2: ottieni le previsioni sul modello di cui è stato eseguito il deployment
Otteneremo le previsioni sul nostro modello addestrato da un notebook Python utilizzando l'API Vertex Python. Torna all'istanza del tuo blocco note e crea un blocco note Python 3 dall'Avvio app:
Nel notebook, esegui il seguente comando in una cella per installare l'SDK Vertex AI:
!pip3 install google-cloud-aiplatform --upgrade --user
Aggiungi una cella nel notebook per importare l'SDK e creare un riferimento all'endpoint appena di cui hai eseguito il deployment:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Dovrai sostituire due valori nella stringa endpoint_name sopra con il numero e l'endpoint del progetto. Per trovare il numero del progetto, vai alla dashboard del progetto e recupera il valore Numero progetto.
Puoi trovare il tuo ID endpoint nella sezione Endpoint della console qui:
Infine, fai una previsione per il tuo endpoint copiando ed eseguendo il codice riportato di seguito in una nuova cella:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Questo esempio ha già valori normalizzati, che è il formato previsto dal nostro modello.
Esegui questa cella e dovresti vedere un output di previsione di circa 16 miglia per gallone.
🎉 Complimenti! 🎉
Hai imparato come utilizzare Vertex AI per:
- Addestra un modello fornendo il codice di addestramento in un container personalizzato. In questo esempio hai utilizzato un modello TensorFlow, ma puoi addestrare un modello creato con qualsiasi framework utilizzando container personalizzati.
- Esegui il deployment di un modello TensorFlow utilizzando un container predefinito nell'ambito dello stesso flusso di lavoro utilizzato per l'addestramento.
- Crea un endpoint del modello e genera una previsione.
Per saperne di più sulle diverse parti di Vertex, consulta la documentazione.
7. Esegui la pulizia
Se vuoi continuare a utilizzare il blocco note creato in questo lab, ti consigliamo di disattivarlo quando non lo usi. Dall'interfaccia utente di Workbench nella console Cloud, seleziona il blocco note, quindi seleziona Interrompi.
Se vuoi eliminare completamente il blocco note, fai clic sul pulsante Elimina in alto a destra.
Per eliminare l'endpoint di cui hai eseguito il deployment, vai alla sezione Endpoint della console Vertex AI, fai clic sull'endpoint che hai creato e seleziona Annulla il deployment del modello nell'endpoint:
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:
