Men-deploy model pada Vertex AI dan mendapatkan prediksi

Setelah melatih model di cluster Ray pada Vertex AI, Anda dapat men-deploy model untuk permintaan prediksi online menggunakan proses berikut:

Sebelum memulai, pastikan untuk membaca ringkasan Ray on Vertex AI dan menyiapkan semua alat prasyarat yang Anda butuhkan.

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

Perbandingan prediksi online Vertex AI dan inferensi Ray

Fitur Prediksi online Vertex AI (Direkomendasikan) Inferensi Sinar (Penyajian Sinar)
Skalabilitas Penskalaan otomatis berdasarkan traffic (sangat skalabel, bahkan untuk model LLM) Sangat skalabel dengan backend terdistribusi dan pengelolaan resource kustom
Pengelolaan Infrastruktur Terkelola sepenuhnya oleh Google Cloud, lebih sedikit overhead operasional Memerlukan lebih banyak penyiapan dan pengelolaan manual di infrastruktur atau cluster Kubernetes Anda
API/Fitur yang Didukung API REST dan gRPC, prediksi batch dan online, fitur penjelasan, batching, caching, streaming API REST dan gRPC, 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 Vertex AI 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, Vertex AI Model Registry, dan integrasi Vertex AI Pipelines Komposisi model tingkat lanjut, model ensemble, logika inferensi kustom, integrasi dengan ekosistem Ray

Mengimpor dan melakukan inisialisasi klien Ray di Vertex AI

Jika sudah terhubung ke cluster Ray di Vertex AI, mulai ulang {i>kernel<i} dan jalankan kode berikut. Variabel runtime_env diperlukan pada waktu koneksi untuk menjalankan perintah prediksi 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()

Dengan keterangan:

  • CLUSTER_RESOURCE_NAME: Nama lengkap resource untuk Ray on Vertex AI cluster yang harus unik di seluruh project Anda.

  • BUCKET_URI adalah bucket Cloud Storage untuk menyimpan model artefak.

Latih dan ekspor model ke Vertex AI Model Registry

Mengekspor model Vertex AI dari checkpoint Ray dan mengupload model 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

  • Konversikan checkpoint Ray ke model.

  • Bangun model.mar.

  • Buat LocalModel menggunakan model.mar.

  • Mengupload ke Vertex AI Model Registry.

Men-deploy model untuk prediksi online

Deploy model ke endpoint online. Untuk 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,
)

Dengan keterangan:

  • (Opsional) DEPLOYED_NAME: Nama tampilan model yang di-deploy. Jika tidak disediakan saat pembuatan, display_name model akan digunakan.

  • (Opsional) TRAFFIC_SPLIT: Peta dari ID model yang di-deploy ke persentase traffic endpoint ini yang harus diteruskan ke model yang di-deploy tersebut. Jika ID model yang di-deploy tidak tercantum dalam peta ini, berarti ID tersebut tidak akan menerima traffic. Jumlah nilai persentase lalu lintas harus mencapai 100, atau peta harus kosong jika endpoint adalah tidak menerima traffic apa pun pada saat ini. Kunci untuk model yang di-deploy adalah "0". Misalnya, {"0": 100}.

  • (Opsional) MACHINE_TYPE: Menentukan resource komputasi.

Membuat permintaan prediksi

Kirim permintaan prediksi ke endpoint. Untuk mengetahui informasi selengkapnya, lihat Mendapatkan prediksi online dari model yang dilatih secara khusus.

pred_request = [
    [ 1.7076793 , 0.23412449, 0.95170785, -0.10901471],
    [-0.81881499, 0.43874669, -0.25108584, 1.75536031]
]

endpoint.predict(pred_request)

Anda akan mendapatkan output seperti berikut:

Prediction(predictions=[0.7891440987586975, 0.5843208432197571],
 deployed_model_id='3829557218101952512',
 model_version_id='1',
 model_resource_name='projects/123456789/locations/us-central1/models/123456789101112',
 explanations=None)

Langkah selanjutnya