Modell auf der Gemini Enterprise Agent Platform bereitstellen, um Inferenzen zu erhalten

Wenn Sie ein Beispiel für die ersten Schritte mit PyTorch on Ray on sehen möchten, führen Sie das Notebook „Erste Schritte mit PyTorch on Ray on “ in einer der folgenden Umgebungen aus:

In Colab öffnen | In Colab Enterprise öffnen | In Vertex AI Workbench öffnen | Auf GitHub ansehen

Nachdem Sie ein Modell in einem Ray-Cluster auf der Gemini Enterprise Agent Platform trainiert haben, können Sie es mithilfe des folgenden Verfahrens für Online-Inferenzanfragen bereitstellen:

Hinweis :Um Batchinferenzen aus den trainierten Modellen zu erhalten, verwenden Sie den folgenden Prozess: Laden Sie das Modell in die Modellregistrierung hoch und folgen Sie dann der Anleitung unter Batchinferenzen aus einem benutzerdefinierten trainierten Modell abrufen.

• Exportieren Sie das Modell aus dem Ray-Prüfpunkt.

• Laden Sie das Modell in Model Registry hoch.

• Modell auf einem Endpunkt bereitstellen

• Inferenzanfragen stellen

Bevor Sie beginnen, sollten Sie den Überblick über Ray in der Agent Platform lesen und alle erforderlichen Tools einrichten.

Bei den Schritten in diesem Abschnitt wird davon ausgegangen, dass Sie das Ray on Agent Platform SDK in einer interaktiven Python-Umgebung verwenden.

Online-Inferenz und Ray-Inferenz in der Gemini Enterprise Agent Platform im Vergleich

Funktion	Online-Inferenz der Gemini Enterprise Agent Platform (empfohlen)	Ray Inference (Ray Serve)
Skalierbarkeit	Autoscaling auf Basis von Traffic (hochskalierbar, auch für LLM-Modelle)	Hohe Skalierbarkeit mit verteilten Back-Ends und benutzerdefiniertem Ressourcenmanagement
Infrastrukturverwaltung	Vollständig verwaltet von Google Cloud, weniger Betriebsaufwand	Erfordert mehr manuelle Einrichtung und Verwaltung in Ihrer Infrastruktur oder Ihrem Kubernetes-Cluster
API/Unterstützte Funktionen	REST- und gRPC-APIs, Online- und Batchinferenzen, Erklärbarkeitsfunktionen, Batching, Caching, Streaming	REST- und gRPC-APIs, Echtzeit- und Batchinferenz, Modellkomposition, Batching, Caching, Streaming
Modellformat	Unterstützt verschiedene Frameworks wie TensorFlow, PyTorch, scikit-learn und XGBoost mit vordefinierten Containern oder benutzerdefinierten Containern	Unterstützt verschiedene Frameworks wie TensorFlow, PyTorch und scikit-learn.
Nutzerfreundlichkeit	Einfacher einzurichten und zu verwalten, in andere Funktionen der Gemini Enterprise Agent Platform integriert	Flexibler und anpassbarer, erfordert aber mehr Wissen über Ray
Kosten	Die Kosten hängen von den Maschinentypen, Beschleunigern und der Anzahl der Replikate ab.	Die Kosten hängen von Ihrer Infrastruktur ab.
Spezialisierte Funktionen	Modellmonitoring, A/B-Tests, Traffic-Aufteilung, Gemini Enterprise Agent Platform Model Registry und Gemini Enterprise Agent Platform Pipelines-Integration	Erweiterte Modellkomposition, Ensemble-Modelle, benutzerdefinierte Inferenzlogik, Integration in das Ray-Ökosystem

Ray on Agent Platform-Client importieren und initialisieren

Wenn Sie bereits mit Ihrem Ray-Cluster auf der Gemini Enterprise Agent Platform verbunden sind, starten Sie den Kernel neu und führen Sie den folgenden Code aus. Die Variable runtime_env ist beim Herstellen der Verbindung erforderlich, um Online-Inferenzbefehle auszuführen.

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

Wobei:

• CLUSTER_RESOURCE_NAME: Der vollständige Ressourcenname für den Ray on Agent Platform-Cluster, der in Ihrem Projekt eindeutig sein muss.

• BUCKET_URI ist der Cloud Storage-Bucket, in dem die Modellartefakte gespeichert werden.

Modell trainieren und in Model Registry exportieren

Exportieren Sie das Gemini Enterprise Agent Platform-Modell aus dem Ray-Prüfpunkt und laden Sie das Modell in die Model Registry hoch.

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

• Konvertieren Sie Ray-Prüfpunkte in ein Modell.

• Erstellen Sie model.mar.

• Erstellen Sie LocalModel mit model.mar.

• Laden Sie es in Model Registry hoch.

Wenn Sie ein Beispiel für die ersten Schritte mit Ray on Vertex AI sehen möchten, führen Sie das Notebook „Erste Schritte mit Ray on “ in einer der folgenden Umgebungen aus:

In Colab öffnen | In Colab Enterprise öffnen | In Vertex AI Workbench öffnen | Auf GitHub ansehen

Modell für Onlineinferenzen bereitstellen

Stellen Sie das Modell für den Online-Endpunkt bereit. Weitere Informationen finden Sie unter Modell auf einem Endpunkt bereitstellen.

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

Dabei gilt:

• (Optional) DEPLOYED_NAME: Der Anzeigename des bereitgestellten Modells. Wenn Sie bei der Erstellung keinen Namen angeben, verwendet das System den display_name des Modells.

• (Optional) TRAFFIC_SPLIT: Eine Zuordnung der ID eines bereitgestellten Modells zum Prozentsatz des Traffics dieses Endpunkts, der an das bereitgestellte Modell weitergeleitet werden soll. Wenn die ID eines bereitgestellten Modells nicht in dieser Tabelle aufgeführt ist, wird kein Traffic an das Modell gesendet. Die Werte für den Traffic-Prozentsatz müssen zusammen 100 ergeben. Wenn der Endpunkt derzeit keinen Traffic akzeptiert, muss die Karte leer sein. Der Schlüssel für das bereitzustellende Modell ist "0". Beispiel: {"0": 100}

• (Optional) MACHINE_TYPE: Geben Sie die Rechenressourcen an.

Inferenzanfrage stellen

Senden Sie eine Inferenzanfrage an den Endpunkt. Weitere Informationen finden Sie unter Onlineinferenzen aus einem benutzerdefinierten trainierten Modell abrufen.

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

endpoint.predict(pred_request)

Die Ausgabe sollte in etwa so aussehen:

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)

Nächste Schritte

• Logs für Ihren Ray-Cluster auf der Gemini Enterprise Agent Platform aufrufen

• Ray-Cluster löschen