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 il deployment di un modello su Vertex AI e ottieni previsioni

Dopo aver addestrato un modello su un cluster Ray su Vertex AI, puoi eseguire il deployment del modello per le richieste di previsione online utilizzando la seguente procedura:

Esporta il modello dal checkpoint Ray.
Carica il modello in Vertex AI Model Registry.
Eseguire il deployment del modello su un endpoint.
Effettuare richieste di previsione.

Prima di iniziare, assicurati di leggere la panoramica di Ray on Vertex AI e di configurare tutti gli strumenti dei prerequisiti di cui hai bisogno.

I passaggi in questa sezione presuppongono l'utilizzo dell'SDK Ray on Vertex AI in un ambiente Python interattivo.

Confronto tra previsione online di Vertex AI e inferenza di Ray

Selezione delle	Previsione online di Vertex AI (consigliata)	Inferenza dei raggi (pubblicazione di raggi)
Scalabilità	Scalabilità automatica basata sul traffico (elevata scalabilità anche per i modelli LLM)	Elevata scalabilità con backend distribuiti e gestione personalizzata delle risorse
Gestione dell'infrastruttura	Completamente gestito da Google Cloud, meno overhead operativo	Richiede una configurazione e una gestione più manuali sull'infrastruttura o sul cluster Kubernetes
API/Funzionalità supportate	API REST e gRPC, previsioni online e batch, caratteristiche di spiegabilità, batch, memorizzazione nella cache, flussi di dati	API REST e gRPC, inferenza in tempo reale e batch, composizione di modelli, raggruppamento in batch, memorizzazione nella cache, flussi di dati
Formato del 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à di utilizzo	Più facili da configurare e gestire, grazie all'integrazione con altre funzionalità di Vertex AI	Più flessibile e personalizzabile, ma richiede una conoscenza più approfondita di Ray
Costo	Il costo dipende da tipi di macchina, acceleratori e numero di repliche	Il costo dipende dalle scelte dell'infrastruttura
Funzionalità specializzate	Monitoraggio del modello, test A/B, suddivisione del traffico, integrazione di Vertex AI Model Registry e integrazione di Vertex AI Pipelines	Composizione avanzata dei modelli, modelli di insieme, logica di inferenza personalizzata, integrazione con l'ecosistema Ray

Importa e inizializza Ray sul client Vertex AI

Se hai già una connessione al tuo cluster Ray su Vertex AI, riavvia il kernel ed esegui il codice seguente. La variabile runtime_env è necessaria al momento della connessione per eseguire i comandi di previsione 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()

Dove:

CLUSTER_RESOURCE_NAME: il nome completo della risorsa per il cluster Ray on Vertex AI che deve essere univoco all'interno del progetto.
BUCKET_URI è il bucket Cloud Storage in cui archiviare gli artefatti del modello.

Addestra ed esporta il modello in Vertex AI Model Registry

Esporta il modello Vertex AI dal checkpoint Ray e caricalo in 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.9.3", # 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 a 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

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

Esegui il deployment del modello per le previsioni online

Eseguire il deployment del modello nell'endpoint online. Per ulteriori informazioni, consulta Eseguire 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,
)