Migra rutinas de predicción personalizadas a Vertex AI

En esta página, se describe cómo migrar las implementaciones de tu rutina de predicción personalizada (CPR) de AI Platform a Vertex AI.

En particular, en una página con implementación de CPR en AI Platform, se muestra cómo hacer lo siguiente:

Crea un contenedor personalizado correspondiente para la implementación en Vertex AI. Este contenedor personalizado funciona como cualquiera que se haya creado con la API de CPR en Vertex AI.
Ejecuta y prueba el contenedor personalizado de manera local.
Súbelo a vertex_model_registry_name.
Implementa el modelo en un endpoint de Vertex AI para entregar predicciones en línea.

Antes de comenzar

Asegúrate de que el siguiente software esté instalado:
Ten los artefactos del modelo y el código personalizado de tu CPR en la implementación de AI Platform que deseas migrar a Vertex AI.
Ten un bucket de Cloud Storage para almacenar los artefactos del modelo
Asegúrate de tener habilitada la API de Vertex AI en tu proyecto.

Habilitar la API de Vertex AI

Prepara la carpeta de origen para la implementación de Vertex AI

Crea una carpeta local llamada model_artifacts y copia los artefactos del modelo de tu CPR en la implementación de AI Platform. Estos deben ser los mismos artefactos del modelo que especificaste en deployment_uri (o --origin si usaste gcloud) cuando implementaste tu CPR en el modelo de AI Platform.
Crea una carpeta local llamada cpr_src_dir. Esta carpeta contendrá tus paquetes de distribución de origen, adapter.py y requirements.txt (que se describen a continuación), que se usan a fin de compilar tu contenedor personalizado para la implementación en Vertex AI.
Copia todos los paquetes que proporcionaste en package_uris cuando implementaste tu CPR en AI Platform, incluido el que contiene tu clase Predictor.

Crea un archivo adapter.py que contenga la clase AdapterPredictor (definida a continuación) y configura PREDICTION_CLASS como el nombre completo de tu clase Predictor. Este valor es el mismo que prediction_class cuando implementaste el CPR en AI Platform.

El adaptador une la CPR en la interfaz Predictor de AI Platform para que sea compatible con la CPR en la interfaz de 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)

Crea un archivo requirements.txt que contenga las dependencias de tu modelo, por ejemplo:
```
# 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
```
En la primera sección, se enumeran las dependencias necesarias para la entrega del modelo.

En la segunda sección, se enumeran los paquetes de aprendizaje automático necesarios para la entrega de modelos (por ejemplo, scikit-learn, xgboost y TensorFlow). Asegúrate de instalar la misma versión de estas bibliotecas como se enumera en la versión del entorno de ejecución que elegiste cuando implementaste anteriormente la versión del modelo.

Instala las dependencias en tu entorno local:

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

Sube tus artefactos de modelos en Cloud Storage

Sube los artefactos de modelos en Cloud Storage

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

Configura Artifact Registry

Artifact Registry se usa para almacenar y administrar las imágenes de contenedor de Docker.

Asegúrate de tener la API de Artifact Registry habilitada en tu proyecto.

Habilitar la API de Artifact Registry

Crea tu repositorio si aún no tienes uno.

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

Antes de poder enviar o extraer imágenes, debes configurar Docker para que use Google Cloud CLI con el objetivo de autenticar las solicitudes enviadas a Artifact Registry.
```
gcloud auth configure-docker {REGION}-docker.pkg.dev
```

Compila, prueba y, luego, implementa tu contenedor personalizado

Con la siguiente secuencia de comandos de Python, se muestra cómo compilar, probar y, también, implementar tu contenedor personalizado mediante las APIs en el SDK de Vertex AI. Asegúrate de configurar las variables en la parte superior de la secuencia de comandos.

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)

Obtén más información sobre Vertex AI Prediction.