Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Esegui il deployment di un modello su Gemini Enterprise Agent Platform per ottenere inferenze

Dopo aver addestrato un modello su un cluster Ray su Gemini Enterprise Agent Platform, esegui il deployment del modello per le richieste di inferenza online utilizzando la seguente procedura:

Esporta il modello dal checkpoint Ray.
Carica il modello in Model Registry.
Eseguire il deployment del modello su un endpoint.
Effettua richieste di inferenza.

Prima di iniziare, assicurati di leggere la panoramica di Ray on Agent Platform e di configurare tutti gli strumenti prerequisiti necessari.

I passaggi descritti in questa sezione presuppongono che tu utilizzi l'SDK Ray on Agent Platform in un ambiente Python interattivo.

Confronto tra l'inferenza online di Gemini Enterprise Agent Platform e l'inferenza di Ray

Funzionalità	Inferenza online di Gemini Enterprise Agent Platform (consigliata)	Inferenza Ray (Ray Serve)
Scalabilità	Scalabilità automatica in base al traffico (altamente scalabile anche per i modelli LLM)	Altamente scalabile con backend distribuiti e gestione personalizzata delle risorse
Infrastructure Management	Completamente gestito da Google Cloud, meno costi operativi generali	Richiede più configurazione e gestione manuali sull'infrastruttura o sul cluster Kubernetes
API/Funzionalità supportate	API REST e gRPC, inferenze online e batch, funzionalità di spiegabilità, batching, memorizzazione nella cache, streaming	API REST e gRPC, inferenza in tempo reale e batch, composizione di modelli, batch, memorizzazione nella cache, streaming
Formato modello	Supporta vari framework come TensorFlow, PyTorch, scikit-learn, XGBoost utilizzando container predefiniti o qualsiasi container personalizzato	Supporta vari framework come TensorFlow, PyTorch e scikit-learn.
Facilità d'uso	Più facile da configurare e gestire, integrato con altre funzionalità di Gemini Enterprise Agent Platform	Più flessibile e personalizzabile, ma richiede una conoscenza più approfondita di Ray
Costo	Il costo dipende dai tipi di macchine, dagli acceleratori e dal numero di repliche	Il costo dipende dalle scelte dell'infrastruttura
Funzionalità specializzate	Monitoraggio dei modelli, test A/B, suddivisione del traffico, integrazione di Model Registry di Gemini Enterprise Agent Platform e di Gemini Enterprise Agent Platform Pipelines	Composizione avanzata dei modelli, modelli di ensemble, logica di inferenza personalizzata, integrazione con l'ecosistema Ray

Importa e inizializza il client Ray on Agent Platform

Se hai già eseguito la connessione al cluster Ray su Gemini Enterprise Agent Platform, riavvia il kernel ed esegui il seguente codice. La variabile runtime_env è necessaria al momento della connessione per eseguire i comandi di inferenza 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 Agent Platform 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()

Dove:

CLUSTER_RESOURCE_NAME: il nome completo della risorsa per il cluster Ray on Agent Platform che deve essere univoco nel tuo progetto.
BUCKET_URI è il bucket Cloud Storage in cui archiviare gli artefatti del modello.

Addestra ed esporta il modello in Model Registry

Esporta il modello Gemini Enterprise Agent Platform dal checkpoint Ray e caricalo in 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 Agent Platform 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 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 Agent Platform 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 Model Registry.
vertex_model = xgboost.register_xgboost(
result.checkpoint,
)

PyTorch

Converti i checkpoint Ray in un modello.
Build model.mar.
Crea LocalModel utilizzando model.mar.
Carica in Model Registry.

Esegui il deployment del modello per le inferenze online

Esegui il deployment del modello sull'endpoint online. Per saperne di più, consulta Esegui il deployment del modello in 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,
)