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

Men-deploy model di Gemini Enterprise Agent Platform untuk mendapatkan inferensi

Setelah melatih model di cluster Ray di Gemini Enterprise Agent Platform, deploy model untuk permintaan inferensi online menggunakan proses berikut:

Ekspor model dari checkpoint Ray.
Mengupload model ke Model Registry.
Men-deploy model ke endpoint.
Membuat permintaan inferensi.

Sebelum memulai, pastikan untuk membaca ringkasan Ray di Agent Platform dan menyiapkan semua alat prasyarat yang Anda butuhkan.

Langkah-langkah di bagian ini mengasumsikan bahwa Anda menggunakan Ray di Agent Platform SDK di lingkungan Python interaktif.

Perbandingan inferensi online Gemini Enterprise Agent Platform dan inferensi Ray

Fitur	Inferensi online Gemini Enterprise Agent Platform (Direkomendasikan)	Inferensi Ray (Ray Serve)
Skalabilitas	Penskalaan otomatis berdasarkan traffic (sangat skalabel bahkan untuk model LLM)	Sangat skalabel dengan backend terdistribusi dan pengelolaan resource kustom
Pengelolaan Infrastruktur	Dikelola sepenuhnya oleh Google Cloud, overhead operasional lebih sedikit	Memerlukan penyiapan dan pengelolaan manual yang lebih banyak di infrastruktur atau cluster Kubernetes Anda
API/Fitur yang Didukung	REST dan gRPC API, inferensi online dan batch, fitur penjelasan, batching, caching, streaming	REST dan gRPC API, inferensi real-time dan batch, komposisi model, batching, caching, streaming
Format Model	Mendukung berbagai framework seperti TensorFlow, PyTorch, scikit-learn, XGBoost menggunakan container bawaan atau container kustom apa pun	Mendukung berbagai framework seperti TensorFlow, PyTorch, scikit-learn.
Kemudahan Penggunaan	Lebih mudah disiapkan dan dikelola, terintegrasi dengan fitur Gemini Enterprise Agent Platform lainnya	Lebih fleksibel dan dapat disesuaikan, tetapi memerlukan pengetahuan yang lebih mendalam tentang Ray
Biaya	Biaya bergantung pada jenis mesin, akselerator, dan jumlah replika	Biaya bergantung pada pilihan infrastruktur Anda
Fitur Khusus	Pemantauan model, pengujian A/B, pemisahan traffic, integrasi Gemini Enterprise Agent Platform Model Registry dan Gemini Enterprise Agent Platform Pipelines	Komposisi model lanjutan, model ensemble, logika inferensi kustom, integrasi dengan ekosistem Ray

Mengimpor dan melakukan inisialisasi klien Ray di Agent Platform

Jika sudah terhubung ke cluster Ray di Gemini Enterprise Agent Platform, mulai ulang kernel dan jalankan kode berikut. Variabel runtime_env diperlukan pada waktu koneksi untuk menjalankan perintah inferensi 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()

Dengan:

CLUSTER_RESOURCE_NAME: Nama lengkap resource untuk cluster Ray di Agent Platform yang harus unik di seluruh project Anda.
BUCKET_URI adalah bucket Cloud Storage untuk menyimpan artefak model.

Melatih dan mengekspor model ke Model Registry

Ekspor model Gemini Enterprise Agent Platform dari checkpoint Ray, lalu upload model ke 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

Konversi checkpoint Ray ke model.
Buat model.mar.
Buat LocalModel menggunakan model.mar.
Upload ke Model Registry.

Men-deploy model untuk inferensi online

Deploy model ke endpoint online. Untuk mengetahui informasi selengkapnya, lihat Men-deploy model ke 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,
)