Migrar rotinas de previsão personalizadas para a Vertex AI

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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 o CPR na Vertex AI.
  • Execute e teste o contêiner personalizado localmente.
  • Faça upload para o Vertex AI Model Registry.
  • 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

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

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

  3. Copie todos os pacotes fornecidos em package_uris ao implantar a CPR na AI Platform, incluindo o que contém a classe Predictor.

  4. Crie um arquivo adapter.py que contenha o AdapterPredictor (mostrado abaixo) e defina PREDICTION_CLASS como o nome totalmente qualificado do 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)
    
  5. 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 do modelo (por exemplo, scikit-learn, xgboost, tensorflow etc.). 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.

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

Fazer upload de artefatos de modelo no Cloud Storage

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

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

    Ativar a API Artifacts Registry

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

    gcloud artifacts repositories create {REPOSITORY} \
        --repository-format=docker \
        --location={REGION}
    
  3. Antes de enviar ou extrair imagens, configure o Docker para usar a Google Cloud CLI para 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 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)

Saiba mais sobre o Vertex AI Prediction.