Migrar rotinas de previsão personalizadas para a Vertex AI

Nesta página, descrevemos como migrar suas implantações de Rotina de previsão personalizada (CPR) do AI Platform para a Vertex AI.

Especificamente, considerando uma implantação de CPR na AI Platform, esta página mostra como:

Crie um contêiner personalizado correspondente para implantação na Vertex AI. Esse contêiner personalizado funciona como qualquer contêiner personalizado criado com a API CPR na Vertex AI.
Execute e teste o contêiner personalizado localmente.
Faça upload para o vertex_model_registry_name.
Implantar o modelo em um endpoint da Vertex AI para exibir previsões on-line.

Antes de começar

Verifique se os seguintes softwares estão instalados:
Tenha os artefatos do modelo e o código personalizado da CPR na implantação do AI Platform que você quer migrar para a Vertex AI.
Tenha um bucket do Cloud Storage para armazenar os artefatos do modelo.
Verifique se a API Vertex AI está ativada no seu projeto.

Ative a API Vertex AI

Prepare a pasta de origem para a implantação da Vertex AI

Crie uma pasta local chamada model_artifacts e copie os artefatos do modelo da CPR na implantação da AI Platform. Eles precisam ser os mesmos artefatos de modelo especificados em deployment_uri (ou --origin, se você usou o gcloud) ao implantar a CPR no modelo do AI Platform.
Crie uma pasta local chamada cpr_src_dir. Ela conterá os pacotes de distribuição de origem, adapter.py e requirements.txt, descritos abaixo, que são usados para criar o contêiner personalizado e implantá-lo na Vertex AI.
Copie todos os pacotes fornecidos em package_uris ao implantar a CPR na AI Platform, incluindo o que contém a classe Predictor.

Crie um arquivo adapter.py que contenha a classe AdapterPredictor (definida abaixo) e defina PREDICTION_CLASS como o nome totalmente qualificado da classe Predictor. Esse valor é o mesmo que prediction_class quando você implantou sua CPR na AI Platform.

O adaptador une o CPR na interface Predictor do AI Platform para que seja compatível com o CPR na interface da 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)

Crie um arquivo requirements.txt com as dependências do seu modelo, por exemplo:
```
# 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
```
A primeira seção lista as dependências necessárias para a exibição do modelo.

A segunda seção lista os pacotes de machine learning necessários para a exibição de modelos (por exemplo, scikit-learn, xgboost e TensorFlow). Instale a mesma versão dessas bibliotecas como listadas na versão de ambiente de execução escolhida ao implantar anteriormente a versão do modelo.

Instale as dependências no ambiente local

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

Fazer upload de artefatos de modelo no Cloud Storage

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

Configurar o Artifact Registry

O Artifact Registry é usado para armazenar e gerenciar as imagens de contêiner do Docker.

Verifique se a API Artifacts Registry está ativada no seu projeto.

Ativar a API Artifacts Registry

Crie seu repositório se ainda não tiver um.

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

Antes de enviar ou extrair imagens, configure o Docker para usar a CLI do Google Cloud e autenticar solicitações ao Artifact Registry.
```
gcloud auth configure-docker {REGION}-docker.pkg.dev
```

Crie, teste e implante seu contêiner personalizado

O script Python a seguir demonstra como criar, testar e implantar seu contêiner personalizado usando as APIs no SDK da Vertex AI. Defina as variáveis na parte superior do 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)

Saiba mais sobre o Vertex AI Prediction.