Prova i modelli Gemini 1.5, gli ultimi modelli multimodali di Vertex AI, e scopri cosa puoi creare con una finestra contestuale fino a 2 milioni di token. Prova i modelli Gemini 1.5, i più recenti modelli multimodali di Vertex AI, e scopri cosa puoi creare con una finestra contestuale fino a 2 milioni di token.

Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui la migrazione delle routine di previsione personalizzate a Vertex AI

Questa pagina descrive come eseguire la migrazione dei deployment della routine di previsione personalizzata (CPR) da AI Platform a Vertex AI.

Nello specifico, in un deployment CPR su AI Platform, questa pagina mostra come:

Crea un container personalizzato corrispondente per il deployment su Vertex AI. Questo container personalizzato funziona come qualsiasi container personalizzato creato con l'API CPR on Vertex AI.
Esegui e testa il container personalizzato in locale.
Caricalo nel vertex_model_registry_name.
Esegui il deployment del modello su Vertex AI endpoint per pubblicare le previsioni online.

Prima di iniziare

Assicurati che sia installato il software seguente:
Disponi degli artefatti del modello e del codice personalizzato di CPR sul deployment di AI Platform di cui vuoi eseguire la migrazione a Vertex AI.
Disporre di un bucket Cloud Storage per archiviare gli artefatti del modello.
Assicurati che l'API Vertex AI sia abilitata nel tuo progetto.

Abilita l'API Vertex AI

Prepara la cartella di origine per il deployment di Vertex AI

Crea una cartella locale denominata model_artifacts e copia gli artefatti del modello dal tuo CPR sul deployment di AI Platform. Devono essere gli stessi artefatti del modello che hai specificato in deployment_uri (o --origin se hai utilizzato gcloud) quando hai eseguito il deployment del CPR sul modello AI Platform.
Crea una cartella locale denominata cpr_src_dir. Questa cartella conterrà i tuoi pacchetti di distribuzione di origine, adapter.py e requirements.txt (descritti di seguito) che vengono utilizzati per creare il tuo container personalizzato per il deployment su Vertex AI.
Copia tutti i pacchetti forniti in package_uris quando hai eseguito il deployment della CPR su AI Platform, incluso quello che contiene la classe Predictor.

Crea un file adapter.py che contenga la classe AdapterPredictor (definita di seguito) e imposta PREDICTION_CLASS sul nome completo della tua classe Predictor. Questo valore è uguale a prediction_class quando hai eseguito il deployment del CPR su AI Platform.

L'adattatore aggrega il CPR nell'interfaccia Predictor di AI Platform in modo che sia compatibile con il CPR sull'interfaccia di 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 file requirements.txt che contenga le dipendenze del modello, ad esempio:
```
# 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 prima sezione elenca le dipendenze necessarie per la pubblicazione del modello.

La seconda sezione elenca i pacchetti di machine learning necessari per la pubblicazione del modello (ad esempio scikit-learn, xgboost e TensorFlow). Assicurati di installare la stessa versione di queste librerie elencata nella versione di runtime che hai scelto durante il deployment precedente della versione del modello.

Installa le dipendenze nel tuo ambiente locale:

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

Carica gli artefatti del modello in Cloud Storage

Carica gli artefatti del modello in Cloud Storage:

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

Configura Artifact Registry

Artifact Registry viene utilizzato per archiviare e gestire le immagini container Docker.

Assicurati che l'API Artifacts Registry sia abilitata nel tuo progetto.

Abilita l'API Artifacts Registry

Crea il repository, se non ne hai già uno.

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

Prima di eseguire il push o il pull delle immagini, configura Docker in modo che utilizzi Google Cloud CLI per autenticare le richieste ad Artifact Registry.
```
gcloud auth configure-docker {REGION}-docker.pkg.dev
```

Crea, testa ed esegui il deployment del tuo container personalizzato

Il seguente script Python mostra come creare, testare ed eseguire il deployment del tuo container personalizzato utilizzando le API nell'SDK Vertex AI. Assicurati di impostare le variabili nella parte superiore dello 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)

Scopri di più su Vertex AI Prediction.