Migrer des routines de prédiction personnalisées vers Vertex AI

Cette page explique comment migrer des déploiements de routines de prédiction personnalisées (CPR) d'AI Platform vers Vertex AI.

Plus précisément, avec un déploiement CPR sur AI Platform donné, cette page vous explique comment :

créer un conteneur personnalisé correspondant pour le déploiement sur Vertex AI. Ce conteneur personnalisé fonctionne comme n'importe quel conteneur personnalisé créé avec CPR sur Vertex AI ;
exécuter et tester le conteneur personnalisé en local ;
l'importer dans le registre de modèles Vertex AI ;
déployer le modèle sur un point de terminaison Vertex AI pour diffuser des prédictions en ligne.

Avant de commencer

Assurez-vous que les logiciels suivants sont installés :
Vous devez disposer des artefacts de modèle et du code personnalisé du déploiement CPR sur AI Platform que vous souhaitez migrer vers Vertex AI.
Vous devez disposer d'un bucket Cloud Storage pour stocker les artefacts de modèle.
Assurez-vous que l'API Vertex AI est activée dans votre projet.

Activer l'API Vertex AI

Préparer le dossier source pour le déploiement sur Vertex AI

Créez un dossier local appelé model_artifacts et copiez-y les artefacts de modèle à partir de votre déploiement CPR sur AI Platform. Il doit s'agir des mêmes artefacts de modèle que ceux que vous avez spécifiés dans deployment_uri (ou --origin si vous avez utilisé gcloud) lors du déploiement de votre CPR sur un modèle AI Platform.
Créez un dossier local appelé cpr_src_dir. Ce dossier contiendra vos packages source de distribution, adapter.py et requirements.txt (décrits ci-dessous), qui servent à créer votre conteneur personnalisé pour le déploiement sur Vertex AI .
Copiez tous les packages que vous avez fournis dans package_uris lorsque vous avez déployé votre CPR sur AI Platform, y compris celui qui contient votre classe Predictor.

Créez un fichier adapter.py contenant le AdapterPredictor (voir ci-dessous) et définissez PREDICTION_CLASS sur le nom complet de votre Predictor. Cette valeur est identique à la prediction_class lorsque vous avez déployé votre CPR sur AI Platform.

L'adaptateur encapsule la CPR sur l'interface Predictor d'AI Platform afin qu'elle soit compatible avec la CPR sur l'interface Vertex AI.

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)

Créez un fichier requirements.txt contenant les dépendances de votre modèle, par exemple :
```
# 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
```
La première section répertorie les dépendances requises pour la diffusion du modèle.

La deuxième section répertorie les packages de machine learning requis pour la diffusion du modèle (par exemple, scikit-learn, xgboost, tensorflow, etc.). Veillez à installer la même version de ces bibliothèques que celle répertoriée sous la version d'exécution que vous avez choisie lors du déploiement précédent de la version de votre modèle.
Installez les dépendances dans votre environnement local :
```
pip install -U --user -r cpr_src_dir/requirements.txt 
```

Importer les artefacts de modèle dans Cloud Storage

Importez les artefacts de modèle dans Cloud Storage :

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

Configurer Artifact Registry

Artifact Registry permet de stocker et de gérer vos images de conteneurs Docker.

Vérifiez que l'API Artifact Registry est activée dans votre projet.

Activer l'API Artifact Registry

Créez votre dépôt si vous n'en possédez pas encore.

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

Avant de pouvoir stocker ou extraire des images, configurez Docker afin qu'il se serve de Google Cloud CLI pour authentifier les requêtes envoyées à Artifact Registry.
```
gcloud auth configure-docker {REGION}-docker.pkg.dev
```

Créer, tester et déployer votre conteneur personnalisé

Le script Python suivant montre comment créer, tester et déployer votre conteneur personnalisé à l'aide des API du SDK Vertex AI. Veillez à définir les variables figurant en tête du script.

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)

En savoir plus sur Vertex AI Prediction.