Migra las rutinas de predicción personalizadas a Vertex AI

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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 cualquier contenedor personalizado creado con CPR en Vertex AI.
  • Ejecuta y prueba el contenedor personalizado de manera local.
  • súbelo a Vertex AI Model Registry.
  • Implementar el modelo en un extremo 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

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

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

  3. Copia todos los paquetes que proporcionaste en package_uris cuando implementaste tu CPR en AI Platform, incluido el que contiene tu clase Predictor.

  4. Crea un archivo adapter.py que contenga el AdapterPredictor (que se muestra a continuación) y establece PREDICTION_CLASS en el nombre completamente calificado de tu 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 AI de Vertex.

    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. 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 (p. ej., scikit-learn, xgboost, tensorflow, etcétera). Asegúrate de instalar la misma versión de estas bibliotecas que se enumeran en la versión del entorno de ejecución que elegiste cuando implementaste tu versión del modelo.

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

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

Configura Artifact Registry

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

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

    Habilita la API de Artifact Registry

  2. Crea tu repositorio si aún no tienes uno.

    gcloud artifacts repositories create {REPOSITORY} \
        --repository-format=docker \
        --location={REGION}
    
  3. Antes de poder enviar o extraer imágenes, configura Docker para que use la CLI de Google Cloud a fin de autenticar las solicitudes a Artifact Registry.

    gcloud auth configure-docker {REGION}-docker.pkg.dev
    

Compila, prueba e 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 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)

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