Vertex AI: Co-Hosten von Modellen auf derselben VM für Vorhersagen

1. Übersicht

In diesem Lab verwenden Sie die Co-Hosting-Modellfunktion in Vertex AI, um mehrere Modelle auf derselben VM für Onlinevorhersagen zu hosten.

Lerninhalte

Die folgenden Themen werden behandelt:

• DeploymentResourcePool erstellen
• Modelle in einem DeploymentResourcePool bereitstellen

Die Gesamtkosten für das Lab in Google Cloud belaufen sich auf 2$.

2. Einführung in Vertex AI

In diesem Lab wird das neueste KI-Produktangebot von Google Cloud verwendet. Vertex AI bindet die ML-Angebote in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Zuvor waren mit AutoML trainierte und benutzerdefinierte Modelle über separate Dienste zugänglich. Das neue Angebot vereint beides in einer einzigen API sowie weitere neue Produkte. Sie können auch vorhandene Projekte zu Vertex AI migrieren. Wenn Sie uns Feedback geben möchten, besuchen Sie die Supportseite.

Vertex AI enthält viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab liegt der Fokus auf den unten aufgeführten Produkten: Predictions und Workbench

3. Anwendungsfall – Übersicht

Beim Bereitstellen von Modellen für den Vertex AI-Vorhersagedienst wird jedes Modell standardmäßig auf seiner eigenen VM bereitgestellt. Um das Hosting kostengünstiger zu gestalten, können Sie mehrere Modelle auf derselben VM hosten, was zu einer besseren Auslastung von Arbeitsspeicher und Rechenressourcen führt. Die Anzahl der Modelle, die Sie auf derselben VM bereitstellen, hängt von den Modellgrößen und Traffic-Mustern ab. Dieses Feature ist jedoch besonders nützlich für Szenarien, in denen Sie viele bereitgestellte Modelle mit spärlichem Traffic haben.

Die Unterstützung des Co-Hosting-Modells führt das Konzept des Ressourcenpools für die Bereitstellung ein, in dem Modelle gruppiert werden, um Ressourcen innerhalb einer VM gemeinsam zu nutzen. Modelle können eine VM gemeinsam nutzen, wenn sie einen Endpunkt teilen oder wenn sie auf verschiedenen Endpunkten bereitgestellt werden. Derzeit müssen Modelle im selben Ressourcenpool dasselbe Container-Image haben, einschließlich der Framework-Version der vordefinierten Container von Vertex Prediction. Darüber hinaus werden in diesem Release nur vordefinierte Vertex Prediction-Container mit dem TensorFlow-Modell-Framework unterstützt. Andere Modell-Frameworks und benutzerdefinierte Container werden noch nicht unterstützt.

4. Umgebung einrichten

Sie benötigen ein Google Cloud Platform-Projekt mit aktivierter Abrechnung, um dieses Codelab auszuführen. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.

Schritt 1: Compute Engine API aktivieren

Gehen Sie zu Compute Engine und wählen Sie Aktivieren aus, falls dies noch nicht geschehen ist.

Schritt 2: Vertex AI API aktivieren

Rufen Sie den Bereich Vertex AI in der Cloud Console auf und klicken Sie auf Vertex AI API aktivieren.

Schritt 3: Vertex AI Workbench-Instanz erstellen

Klicken Sie im Bereich Vertex AI der Cloud Console auf Workbench:

Aktivieren Sie die Notebooks API, falls noch nicht geschehen.

Klicken Sie nach der Aktivierung auf VERWALTETE NOTEBOOKS:

Wählen Sie dann NEUES NOTEBOOK aus.

Geben Sie Ihrem Notebook einen Namen und wählen Sie unter Berechtigung die Option Dienstkonto aus.

Wähle Erweiterte Einstellungen aus.

Wählen Sie unter Sicherheit die Option „Terminal aktivieren“ aus. falls es noch nicht aktiviert ist.

Alle anderen erweiterten Einstellungen können Sie unverändert lassen.

Klicken Sie dann auf Erstellen. Die Bereitstellung der Instanz kann einige Minuten dauern.

Nachdem die Instanz erstellt wurde, wählen Sie OPEN JUPYTERLAB (JUPYTERLAB ÖFFNEN) aus.

5. Modell trainieren

Bevor wir die Co-Hosting-Funktion testen können, müssen wir zuerst ein Modell trainieren und die gespeicherten Modellartefakte in einem Cloud Storage-Bucket speichern. Wir verwenden den Workbench Notebook Executor, um den Trainingsjob zu starten.

Schritt 1: Cloud Storage-Bucket erstellen

Wenn Sie in Ihrem Projekt bereits einen Bucket verwenden möchten, können Sie diesen Schritt überspringen. Andernfalls öffnen Sie im Launcher eine neue Terminalsitzung.

Führen Sie im Terminal den folgenden Befehl aus, um eine Umgebungsvariable für Ihr Projekt zu definieren. Ersetzen Sie dabei your-cloud-project durch die ID Ihres Projekts:

Sie können Ihre Projekt-ID abrufen, indem Sie gcloud config list --format 'value(core.project)' in Ihrem Terminal ausführen

PROJECT_ID='your-cloud-project'

Führen Sie als Nächstes den folgenden Befehl aus, um einen neuen Bucket in Ihrem Projekt zu erstellen.

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

Schritt 2: Notebook-Ausführung starten

Öffnen Sie im Launcher der Workbench-Instanz ein neues TensorFlow 2-Notebook.

Mit dem folgenden Code wird ein binärer Sentimentklassifikator (positiv oder negativ) mit dem Dataset für IMDB-Filmrezensionen trainiert. Fügen Sie den Code in Ihr Notebook ein.

Ersetzen Sie {YOUR_BUCKET} durch den Bucket, den Sie im vorherigen Schritt erstellt haben, oder durch einen anderen Bucket in Ihrem Projekt. Hier speichern wir die gespeicherten Modellartefakte, die wir später benötigen, wenn wir das Modell in Vertex AI Model Registry hochladen.

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)

Klicken Sie dann auf die Schaltfläche Execute (Ausführen).

Konfigurieren Sie dann Ihre Ausführung wie folgt und klicken Sie auf SENDEN.

Auf dem Tab „Ausführungen“ in der Console können Sie den Status Ihres Trainingsjobs verfolgen.

Das Training des Modells dauert etwa 7 Minuten

6. Modell bereitstellen

Schritt 1: Modell hochladen

Kehren Sie nach Abschluss der Ausführung zum Workbench-Notebook zurück, um das Modell hochzuladen. Erstellen Sie ein neues TensorFlow-Notebook.

Importieren Sie zuerst das Vertex AI Python SDK

from google.cloud import aiplatform

Laden Sie dann das Modell hoch und ersetzen Sie {YOUR_BUCKET} durch den Bucket, den Sie im Trainingscode angegeben haben.

# 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')

Zu Demonstrationszwecken laden wir dieses Modell zweimal hoch und erstellen zwei verschiedene Modellressourcen in Vertex AI. So können wir die Bereitstellung mehrerer Modelle an einem einzelnen Endpunkt in einem Ressourcenpool für die Bereitstellung testen. In einem realen Szenario würden Sie zwei verschiedene Modelle haben, anstatt Modelle aus denselben gespeicherten Artefakten zu erstellen. Dies ist jedoch ein Kürzel, damit wir keine weitere Trainingsausführung starten müssen. Außerdem können Sie die beiden Modelle auch an verschiedenen Endpunkten innerhalb desselben Ressourcenpools für die Bereitstellung bereitstellen.

# 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 der Vertex AI Model Registry sollten jetzt beide Modelle angezeigt werden. Der Bereitstellungsstatus ist leer, da die Modelle noch nicht bereitgestellt wurden.

Schritt 2: Endpunkt erstellen

Erstellen Sie einen Endpunkt. Beachten Sie, dass sich dies vom Bereitstellen eines Modells an einem Endpunkt unterscheidet.

endpoint = aiplatform.Endpoint.create('cohost-endpoint')

Nachdem der Endpunkt erstellt wurde, wird er in der Konsole angezeigt.

Schritt 3: DeploymentResourcePool erstellen

Sie können den DeploymentResourcePool mit dem folgenden Befehl erstellen. Achten Sie darauf, {YOUR_PROJECT} durch Ihre Projekt-ID zu ersetzen.

# 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}'

Sie können den Pool anzeigen, indem Sie

!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}

Schritt 4: Modelle auf dem Endpunkt bereitstellen

Nachdem der Ressourcenpool erstellt wurde, können Sie die Modelle im Ressourcenpool bereitstellen.

Zuerst stellen wir model_1 bereit. Achten Sie darauf, MODEL_1_ID und ENDPOINT_ID durch die entsprechenden IDs zu ersetzen.

Sie können die Modell-ID abrufen, indem Sie model_1.name ausführen, und die Endpunkt-ID, indem Sie endpoint.name ausführen

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

Mit dem folgenden Befehl wird model_1 auf dem Endpunkt im Ressourcenpool bereitgestellt.

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}'

Dies dauert einige Minuten. Wenn der Vorgang abgeschlossen ist, wird das Modell auf dem Endpunkt in der Console bereitgestellt.

Als Nächstes können wir model_2 im selben Bereitstellungspool bereitstellen. Wir stellen sie auf demselben Endpunkt wie model_1 bereit. Sie können model_2 aber auch an einem anderen Endpunkt innerhalb desselben Ressourcenpools bereitstellen.

Aktualisieren Sie MODEL_ID mit der ID für model_2. Sie können diese ID auch hier abrufen, indem Sie model_2.name ausführen

MODEL_2_ID="{MODEL_2_ID}"

Stellen Sie dann model_2 bereit. Da model_1 bereits auf dem Endpunkt bereitgestellt wurde, müssen wir trafficSplit aktualisieren, damit der Traffic zwischen den beiden Modellen aufgeteilt wird. Wir müssten trafficSplit nicht aktualisieren, wenn wir model_2 an einem anderen Endpunkt innerhalb desselben Ressourcenpools bereitstellen.

Zum Aktualisieren der Traffic-Aufteilung müssen Sie die DeployedModel-ID für model_1 definieren. Beachten Sie, dass sich diese von der Modell-ID unterscheidet.

Die ID des bereitgestellten Modells können Sie mit endpoint.list_models()[0].id abrufen.

DEPLOYED_MODEL_1_ID = {DEPLOYED_MODEL_1_ID}

Führen Sie dann den folgenden Befehl aus, um das zweite Modell bereitzustellen.

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}'

Auch in diesem Beispiel wurden die beiden Modelle auf demselben Endpunkt bereitgestellt. Sie können die Modelle jedoch auch gemeinsam im selben Ressourcenpool hosten, die auf verschiedenen Endpunkten bereitgestellt werden. In diesem Fall müssen Sie sich nicht um die Aufteilung des Traffics kümmern.

Nachdem das zweite Modell bereitgestellt wurde, werden beide in der Konsole angezeigt.

Schritt 5: Vorhersagen abrufen

Der letzte Schritt besteht darin, den Endpunkt zu testen und Vorhersagen zu erhalten.

Definieren Sie zunächst den Testsatz.

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

Rufen Sie dann „Predict“ auf dem Endpunkt auf, der eine Vorhersage von einem der auf dem Endpunkt bereitgestellten Modelle zurückgibt.

endpoint.predict(instances=x_test)

🎉 Glückwunsch! 🎉

Sie haben gelernt, wie Sie mit Vertex AI Folgendes tun können:

• Modelle für Onlinevorhersagen gemeinsam auf derselben VM hosten

Weitere Informationen zu den verschiedenen Teilen von Vertex finden Sie in der Dokumentation.

7. Bereinigen

Sie sollten die Bereitstellung der Modelle auf dem Endpunkt aufheben, wenn Sie sie nicht verwenden möchten. Sie können den Endpunkt auch vollständig löschen. Sie können ein Modell bei Bedarf jederzeit auf einem Endpunkt noch einmal bereitstellen.

Bei von Workbench verwalteten Notebooks tritt nach 180 Minuten Inaktivität automatisch eine Zeitüberschreitung auf, sodass Sie die Instanz nicht beenden müssen. Wenn Sie die Instanz manuell herunterfahren möchten, klicken Sie in der Console im Abschnitt Vertex AI Workbench auf die Schaltfläche „Stop“. Wenn Sie das Notizbuch vollständig löschen möchten, klicken Sie auf Löschen.

Wenn Sie den Storage-Bucket löschen möchten, gehen Sie im Navigationsmenü der Cloud Console zu „Storage“, wählen Sie den Bucket aus und klicken Sie auf „Löschen“: