Esta página se ha traducido con Cloud Translation API.

Desplegar un modelo en Vertex AI para obtener inferencias

Después de entrenar un modelo en un clúster de Ray en Vertex AI, despliega el modelo para las solicitudes de inferencia online siguiendo este proceso:

Exporta el modelo desde el checkpoint de Ray.
Sube el modelo al registro de modelos de Vertex AI.
Despliega el modelo en un endpoint.
Enviar solicitudes de inferencia.

Antes de empezar, lee el resumen de Ray en Vertex AI y configura todas las herramientas necesarias.

En los pasos de esta sección se da por supuesto que usas el SDK de Ray en Vertex AI en un entorno de Python interactivo.

Comparación entre la inferencia online de Vertex AI y la inferencia de Ray

Función	Inferencia online de Vertex AI (recomendado)	Inferencia de Ray (Ray Serve)
Escalabilidad	Autoescalado basado en el tráfico (altamente escalable incluso para modelos LLM)	Altamente escalable con back-ends distribuidos y gestión de recursos personalizada
Gestión de infraestructuras	Totalmente gestionado por Google Cloud, lo que reduce la sobrecarga operativa	Requiere más configuración y gestión manuales en tu infraestructura o clúster de Kubernetes
APIs y funciones admitidas	APIs REST y gRPC, inferencias online y por lotes, funciones de interpretabilidad, procesamiento por lotes, almacenamiento en caché y streaming	APIs REST y gRPC, inferencia en tiempo real y por lotes, composición de modelos, procesamiento por lotes, almacenamiento en caché y streaming
Formato del modelo	Es compatible con varios frameworks, como TensorFlow, PyTorch, scikit-learn y XGBoost, mediante contenedores precompilados o cualquier contenedor personalizado.	Es compatible con varios frameworks, como TensorFlow, PyTorch y scikit-learn.
Facilidad de uso	Más fácil de configurar y gestionar, integrada con otras funciones de Vertex AI	Más flexible y personalizable, pero requiere un conocimiento más profundo de Ray
Coste	El coste depende de los tipos de máquina, los aceleradores y el número de réplicas	El coste depende de las opciones de infraestructura que elijas
Funciones especializadas	Monitorización de modelos, pruebas A/B, división del tráfico, integración de Vertex AI Model Registry y Vertex AI Pipelines	Composición de modelos avanzada, modelos de conjunto, lógica de inferencia personalizada e integración con el ecosistema de Ray

Importar e inicializar el cliente de Ray en Vertex AI

Si ya te has conectado a tu clúster de Ray en Vertex AI, reinicia tu kernel y ejecuta el siguiente código. La variable runtime_env es necesaria en el momento de la conexión para ejecutar comandos de inferencia 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()

Donde:

CLUSTER_RESOURCE_NAME: Nombre completo del recurso del clúster de Ray en Vertex AI, que debe ser único en todo el proyecto.
BUCKET_URI es el segmento de Cloud Storage en el que se almacenan los artefactos del modelo.

Entrenar el modelo y exportarlo al registro de modelos de Vertex AI

Exporta el modelo de Vertex AI desde el punto de control de Ray y sube el modelo a Vertex AI Model Registry.

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

Convierte los puntos de control de Ray en un modelo.
Compilación model.mar.
Crea un LocalModel con model.mar.
Sube el modelo al registro de modelos de Vertex AI.

Desplegar el modelo para hacer inferencias online

Despliega el modelo en el endpoint online. Para obtener más información, consulta Implementar el modelo en un endpoint.

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,
)