Esta página foi traduzida pela API Cloud Translation.

Implemente um modelo no Vertex AI para obter previsões

Depois de preparar um modelo num cluster do Ray no Vertex AI, implemente o modelo para pedidos de previsão online através do seguinte processo:

Exporte o modelo do ponto de verificação do Ray.
Carregue o modelo para o Registo de modelos Vertex AI.
Implemente o modelo num ponto final.
Fazer pedidos de inferência.

Antes de começar, certifique-se de que lê a vista geral do Ray no Vertex AI e configura todas as ferramentas necessárias.

Os passos nesta secção partem do princípio de que usa o SDK do Ray no Vertex AI num ambiente Python interativo.

Comparação entre a inferência online do Vertex AI e a inferência do Ray

Funcionalidade	Inferência online do Vertex AI (recomendado)	Inferência do Ray (Ray Serve)
Escalabilidade	Escala automática com base no tráfego (altamente escalável, mesmo para modelos GML)	Altamente escalável com back-ends distribuídos e gestão de recursos personalizada
Gestão de infraestruturas	Totalmente gerido pela Google Cloud, menos despesas gerais operacionais	Requer uma configuração e uma gestão mais manuais na sua infraestrutura ou cluster do Kubernetes
API/Funcionalidades suportadas	APIs REST e gRPC, inferências online e em lote, funcionalidades de explicabilidade, processamento em lote, colocação em cache e streaming	APIs REST e gRPC, inferência em tempo real e em lote, composição de modelos, processamento em lote, colocação em cache, streaming
Formato do modelo	Suporta várias frameworks, como TensorFlow, PyTorch, scikit-learn, XGBoost, através de contentores pré-criados ou de qualquer contentor personalizado	Suporta várias frameworks, como TensorFlow, PyTorch e scikit-learn.
Facilidade de utilização	Mais fácil de configurar e gerir, integrado com outras funcionalidades do Vertex AI	Mais flexível e personalizável, mas requer um conhecimento mais profundo do Ray
Custo	O custo depende dos tipos de máquinas, dos aceleradores e do número de réplicas	O custo depende das suas escolhas de infraestrutura
Funcionalidades especializadas	Monitorização de modelos, testes A/B, divisão de tráfego, integração do Registo de modelos do Vertex AI e dos Pipelines do Vertex AI	Composição de modelos avançada, modelos de conjunto, lógica de inferência personalizada, integração com o ecossistema Ray

Importe e inicialize o cliente do Ray no Vertex AI

Se já tiver ligação ao cluster do Ray no Vertex AI, reinicie o kernel e execute o seguinte código. A variável runtime_env é necessária no momento da ligação para executar comandos de inferência online.

import ray
import vertexai

# The CLUSTER_RESOURCE_NAME is the one returned from vertex_ray.create_ray_cluster.
address = 'vertex_ray://{}'.format(CLUSTER_RESOURCE_NAME)

# Initialize Vertex AI to retrieve projects for downstream operations.
vertexai.init(staging_bucket=BUCKET_URI)

# Shutdown cluster and reconnect with required dependencies in the runtime_env.
ray.shutdown()

Onde:

CLUSTER_RESOURCE_NAME: o nome completo do recurso para o cluster do Ray no Vertex AI tem de ser exclusivo no seu projeto.
BUCKET_URI é o contentor do Cloud Storage para armazenar os artefactos do modelo.

Prepare e exporte o modelo para o Registo de modelos Vertex AI

Exporte o modelo do Vertex AI a partir do ponto de verificação do Ray e carregue o modelo para o Registo de modelos do Vertex AI.

TensorFlow

import numpy as np
from ray.air import session, CheckpointConfig, ScalingConfig
from ray.air.config import RunConfig
from ray.train import SyncConfig
from ray.train.tensorflow import TensorflowCheckpoint, TensorflowTrainer
from ray import train
import tensorflow as tf

from vertex_ray.predict import tensorflow

# Required dependencies at runtime
runtime_env = {
  "pip": [
      "ray==2.47.1", # pin the Ray version to prevent it from being overwritten
      "tensorflow",
      "IPython",
      "numpy",
  ],
}

# Initialize  Ray on Vertex AI client for remote cluster connection
ray.init(address=address, runtime_env=runtime_env)

# Define a TensorFlow model.

def create_model():
  model = tf.keras.Sequential([tf.keras.layers.Dense(1, activation="linear", input_shape=(4,))])
  model.compile(optimizer="Adam", loss="mean_squared_error", metrics=["mse"])
  return model

def train_func(config):
  n = 100
  # Create a fake dataset
  # data   : X - dim = (n, 4)
  # target : Y - dim = (n, 1)
  X = np.random.normal(0, 1, size=(n, 4))
  Y = np.random.uniform(0, 1, size=(n, 1))

  strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
  with strategy.scope():
      model = create_model()
      print(model)

  for epoch in range(config["num_epochs"]):
      model.fit(X, Y, batch_size=20)
      tf.saved_model.save(model, "temp/my_model")
      checkpoint = TensorflowCheckpoint.from_saved_model("temp/my_model")
      train.report({}, checkpoint=checkpoint)

trainer = TensorflowTrainer(
  train_func,
  train_loop_config={"num_epochs": 5},
  scaling_config=ScalingConfig(num_workers=1),
  run_config=RunConfig(
      storage_path=f'{BUCKET_URI}/ray_results/tensorflow',
      checkpoint_config=CheckpointConfig(
          num_to_keep=1  # Keep all checkpoints.
      ),
      sync_config=SyncConfig(
          sync_artifacts=True,
      ),
  ),
)

# Train the model.
result = trainer.fit()

# Register the trained model to Vertex AI Model Registry.
vertex_model = tensorflow.register_tensorflow(
  result.checkpoint,
)

sklearn

from vertex_ray.predict import sklearn
from ray.train.sklearn import SklearnCheckpoint

vertex_model = sklearn.register_sklearn(
  result.checkpoint,
)

XGBoost

from vertex_ray.predict import xgboost
from ray.train.xgboost import XGBoostTrainer

# Initialize  Ray on Vertex AI client for remote cluster connection
ray.init(address=address, runtime_env=runtime_env)

# Define an XGBoost model.
train_dataset = ray.data.from_pandas(
pd.DataFrame([{"x": x, "y": x + 1} for x in range(32)]))

run_config = RunConfig(
storage_path=f'{BUCKET_URI}/ray_results/xgboost',
checkpoint_config=CheckpointConfig(
    num_to_keep=1  # Keep all checkpoints.
),
sync_config=SyncConfig(sync_artifacts=True),
)

trainer = XGBoostTrainer(
label_column="y",
params={"objective": "reg:squarederror"},
scaling_config=ScalingConfig(num_workers=3),
datasets={"train": train_dataset},
run_config=run_config,
)
# Train the model.
result = trainer.fit()

# Register the trained model to Vertex AI Model Registry.
vertex_model = xgboost.register_xgboost(
result.checkpoint,
)

PyTorch

Converta os pontos de verificação do Ray num modelo.
Crie model.mar.
Crie um LocalModel com model.mar.
Carregue para o Registo de modelos do Vertex AI.

Implemente o modelo para inferências online

Implemente o modelo no ponto final online. Para mais informações, consulte o artigo Implemente o modelo num ponto final.

DEPLOYED_NAME = model.display_name + "-endpoint"
TRAFFIC_SPLIT = {"0": 100}
MACHINE_TYPE = "n1-standard-4"

endpoint = vertex_model.deploy(
    deployed_model_display_name=DEPLOYED_NAME,
    traffic_split=TRAFFIC_SPLIT,
    machine_type=MACHINE_TYPE,
)