Vertex AI: co-hosting di modelli sulla stessa VM per le previsioni

1. Panoramica

In questo lab utilizzerai la funzionalità dei modelli di co-hosting in Vertex AI per ospitare più modelli sulla stessa VM per le previsioni online.

Cosa imparerai

Imparerai a:

• Crea un DeploymentResourcePool
• Esegui il deployment dei modelli all'interno di un DeploymentResourcePool

Il costo totale per l'esecuzione di 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 concentra sui prodotti evidenziati di seguito: Previsioni e Workbench

3. Panoramica del caso d'uso

Durante il deployment dei modelli nel servizio di previsione Vertex AI, per impostazione predefinita viene eseguito il deployment di ogni modello alla propria VM. Per rendere l'hosting più conveniente, puoi ospitare più modelli sulla stessa VM, con un migliore utilizzo della memoria e delle risorse di calcolo. Il numero di modelli di cui decidi 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 sparso.

Il supporto di modelli 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 il loro deployment viene eseguito in endpoint diversi. Attualmente, 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, mentre non sono ancora supportati altri framework del modello e container personalizzati.

4. 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.

Passaggio 2: abilita l'API Vertex AI

Vai 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

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

Abilita l'API Notebooks, se non lo è già.

Dopo averla attivata, fai clic su NOTEBOOK GESTITI:

Quindi seleziona NUOVO Blocco note.

Assegna un nome al tuo blocco note e seleziona Account di servizio in Autorizzazione

Seleziona Impostazioni avanzate.

In Sicurezza, seleziona "Attiva terminale". se non è già abilitato.

Puoi lasciare invariate tutte le altre impostazioni avanzate.

Quindi, fai clic su Crea. Il provisioning dell'istanza richiederà un paio di minuti.

Dopo aver creato l'istanza, seleziona APRI JUPYTERLAB.

5. Addestramento del modello

Prima di poter provare la funzionalità di co-hosting, dobbiamo addestrare un modello e archiviare gli artefatti del modello salvato in un bucket Cloud Storage. Utilizzeremo l'esecutore del blocco note di Workbench per avviare il job di addestramento.

Passaggio 1: crea un bucket Cloud Storage

Se nel progetto hai già un bucket che vuoi utilizzare, puoi saltare questo passaggio. In caso contrario, da Avvio app si aprirà una nuova sessione del terminale.

Dal terminale, esegui il comando riportato di seguito 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'

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 blocco note

Apri un nuovo blocco note TensorFlow 2 dall'Avvio app dell'istanza Workbench.

Il codice riportato di seguito addestra un classificatore binario del sentiment (positivo o negativo) nel set di dati delle recensioni dei film IMDB. Incolla il codice nel blocco note.

Assicurati di sostituire {YOUR_BUCKET} con il bucket che hai creato nel passaggio precedente (o con un altro bucket nel tuo progetto). È qui che archivieremo gli artefatti del modello salvati, di cui avremo bisogno in seguito 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)

Quindi, seleziona il pulsante Esegui.

Quindi, configura l'esecuzione come segue e fai clic su INVIA

Dalla scheda Esecuzioni nella console, puoi monitorare lo stato del job di addestramento.

L'addestramento del modello richiederà circa 7 minuti

6. Esegui il deployment del modello

Passaggio 1: carica il modello

Al termine dell'esecuzione, torna al blocco note di Workbench per caricare il modello. Creare un nuovo blocco note TensorFlow.

Innanzitutto, importa l'SDK Vertex AI per 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 diverse risorse del modello 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 invece di crearli dagli stessi artefatti salvati, ma questa è una scorciatoia, quindi non è necessario avviare un'altra esecuzione dell'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 questo approccio è diverso 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 il pool di risorse di deployment

Puoi creare il pool di risorse di deployment con il comando seguente. Assicurati di sostituire {YOUR_PROJECT} con l'ID del tuo 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 vedere 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 all'interno del pool di risorse.

Per prima cosa, eseguiremo il deployment di model_1. Assicurati di sostituire MODEL_1_ID e ENDPOINT_ID con i rispettivi ID.

Puoi ottenere l'ID modello eseguendo model_1.name e l'ID endpoint eseguendo endpoint.name

MODEL_1_ID="{MODEL_1_ID}"
ENDPOINT_ID="{ENDPOINT_ID}"

Il seguente comando eseguirà il deployment di model_1 nell'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}'

Questa operazione richiede alcuni minuti, ma al termine vedrai il deployment del modello nell'endpoint nella console.

Ora possiamo eseguire il deployment di model_2 all'interno dello stesso pool di deployment. Eseguiremo il deployment sullo stesso endpoint di model_1. Tuttavia, puoi anche scegliere di eseguire il deployment di model_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}"

quindi esegui il deployment di model_2. Poiché abbiamo già eseguito il deployment di model_1 nell'endpoint, dobbiamo aggiornare trafficSplit in modo che il traffico sia suddiviso tra i due modelli. Non dobbiamo aggiornare trafficSplit se scegliamo di eseguire il deployment di model_2 in 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 è diverso dall'ID modello.

Puoi ottenere l'ID del modello di cui hai eseguito il deployment eseguendo endpoint.list_models()[0].id

DEPLOYED_MODEL_1_ID = {DEPLOYED_MODEL_1_ID}

Quindi esegui il comando riportato di seguito 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}'

Ancora una volta, in questo esempio è stato eseguito il deployment dei due modelli sullo stesso endpoint, ma puoi anche ospitare i modelli nello stesso pool di risorse di cui è stato eseguito il 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.

Per prima cosa, definiamo la frase di prova.

x_test=['The movie was cool. The animation and the graphics were out of this world. I would recommend this movie.']

Quindi, richiama la previsione sull'endpoint, che restituirà una previsione da uno dei modelli di cui è stato eseguito il deployment nell'endpoint.

endpoint.predict(instances=x_test)

🎉 Complimenti! 🎉

Hai imparato come utilizzare Vertex AI per:

• Ospita modelli sulla stessa VM per le previsioni online

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

7. Esegui la pulizia

Ti consigliamo di annullare il deployment dei modelli dall'endpoint se non prevedi di utilizzarli. Puoi anche eliminare completamente l'endpoint. Puoi sempre rieseguire il deployment di un modello in un endpoint, se necessario.

I blocchi note gestiti da 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. Per eliminare completamente il blocco note, fai clic sul pulsante Elimina.

Per eliminare il bucket di archiviazione, utilizzando il menu di navigazione nella console Cloud, vai a Storage, seleziona il bucket e fai clic su Elimina: