1. Panoramica
In questo lab utilizzerai la funzionalità di modello di co-hosting in Vertex AI per ospitare più modelli sulla stessa VM per le previsioni online.
Cosa imparerai
Al termine del corso sarai in grado di:
- Crea un
DeploymentResourcePool - Eseguire il deployment dei modelli all'interno di un
DeploymentResourcePool
Il costo totale per eseguire questo lab su Google Cloud è di circa 2$.
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: Predictions e Workbench.
3. Panoramica del caso d'uso
Quando esegui il deployment dei modelli nel servizio di previsione Vertex AI, per impostazione predefinita ogni modello viene sottoposto a deployment nella propria VM. Per rendere l'hosting più conveniente, puoi ospitare più modelli sulla stessa VM, con conseguente migliore utilizzo della memoria e delle risorse di calcolo. Il numero di modelli che scegli di eseguire il deployment sulla stessa VM dipende dalle dimensioni dei modelli e dai pattern di traffico, ma questa funzionalità è particolarmente utile per gli scenari in cui hai molti modelli di cui è stato eseguito il deployment con traffico scarso.
Il supporto del modello di co-hosting introduce il concetto di pool di risorse di deployment, che raggruppa i modelli per condividere le risorse all'interno di una VM. I modelli possono condividere una VM se condividono un endpoint e anche se vengono implementati in endpoint diversi. Al momento, i modelli nello stesso pool di risorse devono avere la stessa immagine container, inclusa la versione del framework dei container predefiniti di Vertex Prediction. Inoltre, in questa release sono supportati solo i container predefiniti di Vertex Prediction con il framework del modello TensorFlow. Gli altri framework del modello e i container personalizzati non sono ancora supportati.
4. Configura l'ambiente
Per eseguire questo codelab, devi avere un progetto Google Cloud Platform 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 Abilita se non è già abilitato.
Passaggio 2: attiva l'API Vertex AI
Accedi alla sezione Vertex AI della tua console Cloud e fai clic su Abilita API Vertex AI.
Passaggio 3: crea un'istanza di Vertex AI Workbench
Nella sezione Vertex AI della console Cloud, fai clic su Workbench:
Abilita l'API Notebooks, se non l'hai già fatto.
Una volta attivata, fai clic su BLOCCHI NOTE GESTITI:
Poi seleziona NUOVO QUADERNO.
Assegna un nome al notebook e, in Autorizzazione, seleziona Service account.
Seleziona Impostazioni avanzate.
Nella sezione Sicurezza, seleziona "Abilita terminale" se non è già abilitata.
Puoi lasciare invariate tutte le altre impostazioni avanzate.
Quindi, fai clic su Crea. Il provisioning dell'istanza richiede un paio di minuti.
Una volta creata l'istanza, seleziona APRI JUPYTERLAB.
5. Addestramento del modello
Prima di poter provare la funzionalità di co-hosting, dobbiamo prima addestrare un modello e archiviare gli artefatti del modello salvato in un bucket Cloud Storage. Utilizzeremo lo strumento di esecuzione dei notebook Workbench per avviare il job di addestramento.
Passaggio 1: crea un bucket Cloud Storage
Se hai già un bucket nel tuo progetto che vuoi utilizzare, puoi saltare questo passaggio. In caso contrario, apri una nuova sessione di terminale da Avvio app.
Dal 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 questo comando per creare un nuovo bucket nel tuo progetto.
BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET
Passaggio 2: avvia l'esecuzione del notebook
Dall'Avvio app dell'istanza Workbench, apri un nuovo notebook TensorFlow 2.
Il codice riportato di seguito addestra un classificatore del sentiment binario (positivo o negativo) sul set di dati delle recensioni dei film IMDB. Incolla il codice nel notebook.
Assicurati di sostituire {YOUR_BUCKET} con il bucket creato nel passaggio precedente (o un altro bucket nel tuo progetto). Qui archivieremo gli artefatti del modello salvato, che ci serviranno in un secondo momento quando caricheremo il modello in Vertex AI Model Registry.
import numpy as np
import tensorflow_datasets as tfds
import tensorflow as tf
# REPLACE WITH YOUR BUCKET!
OUTPUT_PATH='gs://{YOUR_BUCKET}/model_output'
BUFFER_SIZE = 10000
BATCH_SIZE = 64
VOCAB_SIZE = 1000
# Load data
dataset, info = tfds.load('imdb_reviews', with_info=True,
as_supervised=True)
train_dataset, test_dataset = dataset['train'], dataset['test']
train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
test_dataset = test_dataset.batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
# Create text encoder
encoder = tf.keras.layers.TextVectorization(
max_tokens=VOCAB_SIZE)
encoder.adapt(train_dataset.map(lambda text, label: text))
# Create model
model = tf.keras.Sequential([
encoder,
tf.keras.layers.Embedding(
input_dim=len(encoder.get_vocabulary()),
output_dim=64,
# Use masking to handle the variable sequence lengths
mask_zero=True),
tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(1)
])
# Compile model
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(1e-4),
metrics=['accuracy'])
# Fit model
history = model.fit(train_dataset, epochs=10,
validation_data=test_dataset,
validation_steps=30)
# Save model
model.save(OUTPUT_PATH)
Successivamente, seleziona il pulsante Esegui.
Poi configura l'esecuzione come segue e fai clic su INVIA.
Nella scheda Esecuzioni della console, puoi monitorare lo stato del job di addestramento.
6. Esegui il deployment del modello
Passaggio 1: carica il modello
Al termine dell'esecuzione, torna al notebook Workbench per caricare il modello. Crea un nuovo notebook TensorFlow.
Per prima cosa, importa l'SDK Vertex AI Python
from google.cloud import aiplatform
Quindi carica il modello, sostituendo {YOUR_BUCKET} con il bucket specificato nel codice di addestramento.
# replace {YOUR_BUCKET}
model_1 = aiplatform.Model.upload(display_name='text-model-1',
artifact_uri='gs://{YOUR_BUCKET}/model_output',
serving_container_image_uri='us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest')
A scopo dimostrativo, caricheremo questo modello due volte, creando due risorse modello diverse in Vertex AI. In questo modo possiamo testare il deployment di più modelli in un singolo endpoint all'interno di un pool di risorse di deployment. In uno scenario reale, avresti due modelli diversi anziché creare modelli dagli stessi artefatti salvati, ma questa è una scorciatoia per non dover avviare un'altra esecuzione di addestramento. Inoltre, puoi anche scegliere di eseguire il deployment dei due modelli in endpoint diversi all'interno dello stesso pool di risorse di deployment.
# replace {YOUR_BUCKET}
model_2 = aiplatform.Model.upload(display_name='text-model-2',
artifact_uri='gs://{YOUR_BUCKET}/model_output',
serving_container_image_uri='us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest')
In Vertex AI Model Registry, ora dovresti vedere entrambi i modelli. Lo stato del deployment è vuoto perché non abbiamo ancora eseguito il deployment dei modelli.
Passaggio 2: crea un endpoint
Crea un endpoint. Tieni presente che questa operazione è diversa dal deployment di un modello in un endpoint.
endpoint = aiplatform.Endpoint.create('cohost-endpoint')
Una volta creato l'endpoint, lo vedrai nella console.
Passaggio 3: crea DeploymentResourcePool
Puoi creare DeploymentResourcePool con il seguente comando. Assicurati di sostituire {YOUR_PROJECT} con l'ID progetto.
# replace {YOUR_PROJECT}
PROJECT_ID={YOUR_PROJECT}
REGION="us-central1"
VERTEX_API_URL=REGION + "-aiplatform.googleapis.com"
VERTEX_PREDICTION_API_URL=REGION + "-prediction-aiplatform.googleapis.com"
MULTI_MODEL_API_VERSION="v1beta1"
# Give the pool a name
DEPLOYMENT_RESOURCE_POOL_ID="my-resource-pool"
import json
import pprint
pp = pprint.PrettyPrinter(indent=4)
CREATE_RP_PAYLOAD = {
"deployment_resource_pool":{
"dedicated_resources":{
"machine_spec":{
"machine_type":"n1-standard-4"
},
"min_replica_count":1,
"max_replica_count":2
}
},
"deployment_resource_pool_id":DEPLOYMENT_RESOURCE_POOL_ID
}
CREATE_RP_REQUEST=json.dumps(CREATE_RP_PAYLOAD)
pp.pprint("CREATE_RP_REQUEST: " + CREATE_RP_REQUEST)
!curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/deploymentResourcePools \
-d '{CREATE_RP_REQUEST}'
Puoi visualizzare il pool eseguendo
!curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/deploymentResourcePools/{DEPLOYMENT_RESOURCE_POOL_ID}
Passaggio 4: esegui il deployment dei modelli nell'endpoint
Ora che il pool di risorse è stato creato, possiamo eseguire il deployment dei modelli al suo interno.
Per prima cosa, eseguiamo il deployment di model_1. Assicurati di sostituire MODEL_1_ID e ENDPOINT_ID con gli ID rispettivi.
MODEL_1_ID="{MODEL_1_ID}"
ENDPOINT_ID="{ENDPOINT_ID}"
Il seguente comando eseguirà il deployment di model_1 sull'endpoint all'interno del pool di risorse.
MODEL_NAME = "projects/{project_id}/locations/{region}/models/{model_id}".format(project_id=PROJECT_ID, region=REGION, model_id=MODEL_1_ID)
SHARED_RESOURCE = "projects/{project_id}/locations/{region}/deploymentResourcePools/{deployment_resource_pool_id}".format(project_id=PROJECT_ID, region=REGION, deployment_resource_pool_id=DEPLOYMENT_RESOURCE_POOL_ID)
DEPLOY_MODEL_PAYLOAD = {
"deployedModel": {
"model": MODEL_NAME,
"shared_resources": SHARED_RESOURCE
},
"trafficSplit": {
"0": 100
}
}
DEPLOY_MODEL_REQUEST=json.dumps(DEPLOY_MODEL_PAYLOAD)
pp.pprint("DEPLOY_MODEL_REQUEST: " + DEPLOY_MODEL_REQUEST)
!curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/endpoints/{ENDPOINT_ID}:deployModel \
-d '{DEPLOY_MODEL_REQUEST}'
L'operazione richiederà alcuni minuti, ma al termine vedrai il modello di cui è stato eseguito il deployment nell'endpoint della console.
Successivamente, possiamo eseguire il deployment di model_2 all'interno dello stesso pool di deployment. Eseguiremo il deployment nello stesso endpoint di model_1. Tuttavia, puoi anche scegliere di eseguire il deployment dimodel_2 in un endpoint diverso all'interno dello stesso pool di risorse.
Aggiorna MODEL_ID con l'ID di model_2. Anche in questo caso, puoi ottenere questo ID eseguendo model_2.name
MODEL_2_ID="{MODEL_2_ID}"
Poi esegui il deployment di model_2. Poiché abbiamo già implementato model_1 nell'endpoint, dovremo aggiornare trafficSplit in modo che il traffico venga suddiviso tra i due modelli. Non dovremmo aggiornare trafficSplit se scegliamo di eseguire il deployment di model_2 su un endpoint diverso all'interno dello stesso pool di risorse.
Per aggiornare la suddivisione del traffico, devi definire l'ID DeployedModel per model_1. Tieni presente che questo valore è diverso dall'ID modello.
DEPLOYED_MODEL_1_ID = {DEPLOYED_MODEL_1_ID}
Quindi esegui il comando seguente per eseguire il deployment del secondo modello.
MODEL_NAME = "projects/{project_id}/locations/{region}/models/{model_id}".format(project_id=PROJECT_ID, region=REGION, model_id=MODEL_2_ID)
SHARED_RESOURCE = "projects/{project_id}/locations/{region}/deploymentResourcePools/{deployment_resource_pool_id}".format(project_id=PROJECT_ID, region=REGION, deployment_resource_pool_id=DEPLOYMENT_RESOURCE_POOL_ID)
#`trafficSplit` is a map from a DeployedModel's ID to the percentage of this Endpoint's traffic that should be forwarded to that DeployedModel.
# The traffic percentage values for an endpoint must add up to 100.
# The key for the model being deployed is "0".
DEPLOY_MODEL_PAYLOAD = {
"deployedModel": {
"model": MODEL_NAME,
"shared_resources": SHARED_RESOURCE
},
"trafficSplit": {
"0": 50,
DEPLOYED_MODEL_1_ID: 50
}
}
DEPLOY_MODEL_REQUEST=json.dumps(DEPLOY_MODEL_PAYLOAD)
pp.pprint("DEPLOY_MODEL_REQUEST: " + DEPLOY_MODEL_REQUEST)
!curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/endpoints/{ENDPOINT_ID}:deployModel \
-d '{DEPLOY_MODEL_REQUEST}'
Anche in questo esempio, i due modelli sono stati sottoposti a deployment nello stesso endpoint, ma puoi anche co-ospitare modelli nello stesso pool di risorse sottoposti a deployment in endpoint diversi. In questo caso, non dovrai preoccuparti della suddivisione del traffico.
Dopo il deployment del secondo modello, li vedrai entrambi nella console.
Passaggio 5: ottieni le previsioni
Il passaggio finale consiste nel testare l'endpoint e ottenere previsioni.
Innanzitutto, definiamo la frase di test.
x_test=['The movie was cool. The animation and the graphics were out of this world. I would recommend this movie.']
Quindi, chiama predict sull'endpoint, che restituirà una previsione da uno dei modelli di cui è stato eseguito il deployment nell'endpoint.
endpoint.predict(instances=x_test)
🎉 Congratulazioni! 🎉
Hai imparato come utilizzare Vertex AI per:
- Esegui l'hosting congiunto dei modelli sulla stessa VM per le previsioni online
Per saperne di più sulle diverse parti di Vertex, consulta la documentazione.
7. Esegui la pulizia
Se non prevedi di utilizzarli, annulla il deployment dei modelli dall'endpoint. Puoi anche eliminare completamente l'endpoint. Se necessario, puoi sempre eseguire nuovamente il deployment di un modello su un endpoint.
I notebook gestiti di Workbench scadono automaticamente dopo 180 minuti di inattività, quindi non devi preoccuparti di arrestare l'istanza. Se vuoi arrestare manualmente l'istanza, fai clic sul pulsante Arresta 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 Google Cloud, vai a Storage, seleziona il bucket e fai clic su Elimina:
