Benutzerdefinierte Vorhersageroutinen zu Vertex AI migrieren

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

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 andere benutzerdefinierte Container, der mit CPR in Vertex AI erstellt wurde.
  • Benutzerdefinierte Container lokal ausführen und testen.
  • Sie in die Vertex AI Model Registry hochladen.
  • Ein Modell in einem Vertex AI-Endpunkt für Onlinevorhersagen bereitstellen.

Hinweis

  • 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, um die Modellartefakte zu speichern.

  • 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

  1. Erstellen Sie einen lokalen Ordner mit dem Namen model_artifacts und kopieren Sie die Modellartefakte aus Ihrer CPR in der AI Platform-Bereitstellung. Dies sollten dieselben Modellartefakte sein, die Sie bei der Bereitstellung Ihres CPR im AI Platform-Modell in deployment_uri (oder --origin, wenn Sie gcloud verwendet haben) angegeben haben.

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

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

  4. Erstellen Sie eine adapter.py-Datei, die die AdapterPredictor (siehe unten) enthält, und legen Sie PREDICTION_CLASS auf den vollständig qualifizierten Namen Ihres Predictor fest. Dieser Wert entspricht dem Wert prediction_class, wenn Sie Ihre CPR in AI Platform bereitgestellt haben.

    Der Adapter umschließt die CPR in der Predictor-Schnittstelle von AI Platform, sodass sie mit der CPR in 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)
    
  5. 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, tensorflow usw.). Achten Sie darauf, dieselbe Version dieser Bibliotheken unter der Laufzeitversion zu installieren, die Sie bei der vorherigen Bereitstellung Ihrer Modellversion ausgewählt haben.

  6. 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:

gsutil cp model_artifacts/* gs://BUCKET_NAME/MODEL_ARTIFACT_DIR

Artifact Registry einrichten

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

  1. Die Artifacts Registry API muss in Ihrem Projekt aktiviert sein.

    Artifacts Registry API aktivieren

  2. Erstellen Sie Ihr Repository, falls noch nicht geschehen.

    gcloud artifacts repositories create {REPOSITORY} \
        --repository-format=docker \
        --location={REGION}
    
  3. Um Images hoch- oder herunterladen zu können, konfigurieren Sie Docker für die Verwendung der Google Cloud CLI zum Authentifizieren von Anfragen an Artifact Registry.

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