Benutzerdefinierte Vorhersageroutinen zu Vertex AI migrieren

Auf dieser Seite wird beschrieben, wie Sie Ihre Bereitstellungen benutzerdefinierten Vorhersageroutinen (CPR, Custom Prediction Routine) von AI Platform zu Vertex AI migrieren.

Für CPR-Bereitstellungen in AI Platform erfahren Sie auf dieser Seite, wie Sie:

Einen entsprechenden benutzerdefinierten Container für das Bereitstellung in Vertex AI erstellen. Dieser benutzerdefinierte Container funktioniert wie jeder benutzerdefinierte Container, der mit der CPR on Vertex AI API erstellt wurde.
Benutzerdefinierte Container lokal ausführen und testen.
Laden Sie ihn in vertex_model_registry_name hoch.
Ein Modell in einem Vertex AI-endpoint für Onlinevorhersagen bereitstellen.

Hinweise

Achten Sie darauf, dass folgende Software installiert ist:
Halten Sie die Modellartefakte und den benutzerdefinierten Code aus Ihrer CPR in AI Platform-Bereitstellung bereit, die Sie zu Vertex AI migrieren möchten.
Sie benötigen einen Cloud Storage-Bucket zum Speichern der Modellartefakte.
Achten Sie darauf, dass die Vertex AI API in Ihrem Projekt aktiviert ist.

Vertex AI API aktivieren

Quellordner für die Bereitstellung von Vertex AI vorbereiten

Erstellen Sie einen lokalen Ordner mit dem Namen model_artifacts und kopieren Sie die Modellartefakte aus dem CPR in der AI Platform-Bereitstellung. Dies sollten dieselben Modellartefakte sein, die Sie bei der Bereitstellung Ihres CPR auf dem AI Platform-Modell in deployment_uri (oder --origin, wenn Sie gcloud verwendet haben) angegeben haben.
Erstellen Sie einen lokalen Ordner mit dem Namen cpr_src_dir. Dieser Ordner enthält die Quelldistributionspakete, adapter.py und requirements.txt (siehe unten), mit denen der benutzerdefinierte Container für die Bereitstellung in Vertex AI erstellt wird.
Kopieren Sie alle Pakete, die Sie in package_uris angegeben haben, als Sie Ihre CPR in AI-Platform bereitgestellt haben, einschließlich des Pakets, das die Predictor-Klasse enthält.

Erstellen Sie eine adapter.py-Datei mit der Klasse AdapterPredictor (unten definiert) und legen Sie PREDICTION_CLASS auf den vollständig qualifizierten Namen der Klasse Predictor fest. Dieser Wert entspricht prediction_class, wenn Sie Ihre CPR in AI Platform bereitgestellt haben.

Der Adapter fastt die CPR in der Predictor-Schnittstelle der der AI-Platform zusammen, sodass sie mit der CPR auf der Vertex AI-Schnittstelle kompatibel ist.

import pydoc

from google.cloud.aiplatform.utils import prediction_utils
from google.cloud.aiplatform.prediction.predictor import Predictor

# Fully qualified name of your CPR on CAIP Predictor class.
PREDICTION_CLASS = "predictor.MyPredictor"

class AdapterPredictor(Predictor):
  """Predictor implementation for adapting CPR on CAIP predictors."""

  def __init__(self):
      return

  def load(self, artifacts_uri: str):
      """Loads the model artifact.

      Args:
          artifacts_uri (str):
              Required. The model artifacts path (may be local or on Cloud Storage).
      """
      prediction_utils.download_model_artifacts(artifacts_uri)
      custom_class = pydoc.locate(PREDICTION_CLASS)
      self._predictor = custom_class.from_path(".")

  def predict(self, instances):
      """Performs prediction.

      Args:
          instances (Any):
              Required. The instance(s) used for performing prediction.

      Returns:
          Prediction results.
      """
      return self._predictor.predict(**instances)

Erstellen Sie eine requirements.txt-Datei, die die Abhängigkeiten Ihres Modells enthält. Beispiel:
```
# Required for model serving
google-cloud-storage>=1.26.0,<2.0.0dev
google-cloud-aiplatform[prediction]>=1.16.0

# ML dependencies
numpy>=1.16.0
scikit-learn==0.20.2
```
Im ersten Abschnitt werden die Abhängigkeiten aufgeführt, die für die Modellbereitstellung erforderlich sind.

Im zweiten Abschnitt werden die für die Modellbereitstellung erforderlichen Pakete für maschinelles Lernen aufgeführt (z. B. scikit-learn, xgboost und TensorFlow). Achten Sie darauf, dass Sie dieselbe Version dieser Bibliotheken wie unter der Laufzeitversion aufgeführt installieren, die Sie bei der vorherigen Bereitstellung der Modellversion ausgewählt haben.

Abhängigkeiten in Ihrer lokalen Umgebung installieren:

pip install -U --user -r cpr_src_dir/requirements.txt

Modellartefakte in Cloud Storage hochladen

Modellartefakte in Cloud Storage hochladen:

gcloud storage cp model_artifacts/* gs://BUCKET_NAME/MODEL_ARTIFACT_DIR

Artifact Registry einrichten

Artifact Registry wird zum Speichern und Verwalten Ihrer Docker-Container-Images verwendet.

Achten Sie darauf, dass die Artifact Registry API in Ihrem Projekt aktiviert ist.

Artifacts Registry API aktivieren

Erstellen Sie Ihr Repository, falls Sie noch keines haben.

gcloud artifacts repositories create {REPOSITORY} \
    --repository-format=docker \
    --location={REGION}

Bevor Sie Images hoch‑ oder herunterladen können, müssen Sie Docker so konfigurieren, dass die Google Cloud CLI zum Authentifizieren von Anfragen an Artifact Registry verwendet wird.
```
gcloud auth configure-docker {REGION}-docker.pkg.dev
```

Benutzerdefinierten Container erstellen, testen und bereitstellen

Das folgende Python-Skript zeigt, wie Sie mit den APIs im Vertex AI SDK Ihren benutzerdefinierten Container erstellen, testen und bereitstellen. Achten Sie darauf, die Variablen oben im Skript festzulegen.

import json
import logging
import os

from google.cloud import aiplatform
from google.cloud.aiplatform.prediction import LocalModel
from cpr_src_dir.adapter import AdapterPredictor

##########################################################################
# CONFIGURE THE FOLLOWING
##########################################################################
# We recommend that you choose the region closest to you.
REGION = …
# Your project ID.
PROJECT_ID = …
# Name of the Artifact Repository to create or use.
REPOSITORY = …
# Name of the container image that will be pushed.
IMAGE = …
# Cloud Storage bucket where your model artifacts will be stored.
BUKCET_NAME = …
# Directory within the bucket where your model artifacts are stored.
MODEL_ARTIFACT_DIR = …
# Your model's input instances.
INSTANCES = …

##########################################################################
# Build the CPR custom container
##########################################################################
local_model = LocalModel.build_cpr_model(
    "cpr_src_dir",
    f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
    predictor=AdapterPredictor,
    requirements_path="cpr_src_dir/requirements.txt",
    extra_packages=["cpr_src_dir/my_custom_code-0.1.tar.gz"],
)

##########################################################################
# Run and test the custom container locally
##########################################################################
logging.basicConfig(level=logging.INFO)

local_endpoint =
       local_model.deploy_to_local_endpoint(artifact_uri="model_artifacts")
local_endpoint.serve()

health_check_response = local_endpoint.run_health_check()

predict_response = local_endpoint.predict(
        request=json.dumps({"instances": INSTANCES}),
        headers={"Content-Type": "application/json"},
    )

local_endpoint.stop()

print(predict_response, predict_response.content)
print(health_check_response, health_check_response.content)
local_endpoint.print_container_logs(show_all=True)

##########################################################################
# Upload and deploy to Vertex
##########################################################################
local_model.push_image()

model = aiplatform.Model.upload(\
    local_model=local_model,
    display_name=MODEL_DISPLAY_NAME,
    artifact_uri=f"gs://{BUKCET_NAME}/{MODEL_ARTIFACT_DIR}",
)

endpoint = model.deploy(machine_type="n1-standard-4")

endpoint.predict(instances=INSTANCES)

Weitere Informationen zu Vertex AI Prediction