Onlinevorhersage abrufen

Mit dem Onlinevorhersagedienst von Vertex AI können Sie synchrone Anfragen an Ihren eigenen Vorhersagemodellendpunkt senden.

Auf dieser Seite erfahren Sie, wie Sie Anfragen an Ihr Modell senden, damit es Onlinevorhersagen mit niedriger Latenz bereitstellen kann.

Hinweise

Bevor Sie die Online Prediction API verwenden können, benötigen Sie ein Projekt und die entsprechenden Anmeldedaten.

Führen Sie die folgenden Schritte aus, bevor Sie eine Onlinevorhersage abrufen:

  1. Projekt für Vertex AI einrichten

  2. Bitten Sie Ihren Projekt-IAM-Administrator, Ihnen die Rolle „Vertex AI Prediction User“ (vertex-ai-prediction-user) zuzuweisen, um die Berechtigungen zu erhalten, die Sie für den Zugriff auf die Onlinevorhersage benötigen.

    Informationen zu dieser Rolle finden Sie unter IAM-Berechtigungen vorbereiten.

  3. Erstellen und trainieren Sie ein Vorhersagemodell, das auf einen der unterstützten Container ausgerichtet ist.

  4. Erstellen Sie den Vorhersagecluster und sorgen Sie dafür, dass in Ihrem Projekt eingehender externer Traffic zulässig ist.

  5. Modellartefakte für Vorhersagen exportieren

  6. Modell auf einem Endpunkt bereitstellen

  7. Details der benutzerdefinierten Ressource Endpoint Ihres Vorhersagemodells ansehen:

    kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG get endpoint PREDICTION_ENDPOINT -n PROJECT_NAMESPACE -o jsonpath='{.status.endpointFQDN}'

    Ersetzen Sie Folgendes:

    • PREDICTION_CLUSTER_KUBECONFIG: der Pfad zur kubeconfig-Datei im Vorhersagecluster.
    • PREDICTION_ENDPOINT: der Name des Endpunkts.
    • PROJECT_NAMESPACE: der Name des Namespace des Vorhersageprojekts.

    In der Ausgabe muss das Feld status mit dem vollständig qualifizierten Domainnamen des Endpunkts im Feld endpointFQDN angezeigt werden. Registrieren Sie diesen Endpunkt-URL-Pfad, um ihn für Ihre Anfragen zu verwenden.

Umgebungsvariablen festlegen

Wenn Sie eine Anfrage an Ihren Modellendpunkt mit einem Python-Skript senden möchten und ein Dienstkonto in Ihrem Projekt einrichten, um autorisierte API-Aufrufe programmatisch auszuführen, können Sie Umgebungsvariablen im Skript definieren, um beim Ausführen auf Werte wie die Dienstkontoschlüssel zuzugreifen.

So legen Sie erforderliche Umgebungsvariablen in einem Python-Skript fest:

  1. Erstellen Sie ein JupyterLab-Notebook, um mit der Online Prediction API zu interagieren.

  2. Erstellen Sie ein Python-Skript im JupyterLab-Notebook.

  3. Fügen Sie dem Python-Skript den folgenden Code hinzu:

    import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "APPLICATION_DEFAULT_CREDENTIALS_FILENAME"

    Ersetzen Sie APPLICATION_DEFAULT_CREDENTIALS_FILENAME durch den Namen der JSON-Datei, die die von Ihnen im Projekt erstellten Dienstkontoschlüssel enthält, z. B. my-service-key.json.

  4. Speichern Sie das Python-Skript unter einem Namen, z. B. prediction.py.

  5. Führen Sie das Python-Skript aus, um die Umgebungsvariablen festzulegen:

    python SCRIPT_NAME

    Ersetzen Sie SCRIPT_NAME durch den Namen, den Sie Ihrem Python-Skript gegeben haben, z. B. prediction.py.

Anfrage an einen Endpunkt senden

Senden Sie eine Anfrage an den Endpunkt des Modells, um eine Onlinevorhersage zu erhalten:

curl

So stellen Sie eine curl-Anfrage:

  1. Erstellen Sie eine JSON-Datei mit dem Namen request.json für den Anfragetext.

    Sie müssen die Eingabe für die Onlinevorhersage mit den Details des Anfragetexts hinzufügen und formatieren, die der Zielcontainer erfordert.

  2. Authentifizierungstoken abrufen

  3. Stellen Sie die Anfrage:

    curl -X POST -H "Content-Type: application/json; charset=utf-8" -H "Authorization: Bearer TOKEN"
https://ENDPOINT:443/v1/model:predict -d @request.json

    Ersetzen Sie Folgendes:

Bei erfolgreicher Ausführung erhalten Sie eine JSON-Antwort auf Ihre Onlinevorhersageanfrage.

Die folgende Ausgabe zeigt ein Beispiel:

{
    "predictions": [[-357.10849], [-171.621658]
    ]
}

Weitere Informationen zu Antworten finden Sie unter Details zum Antworttext.

Python

So verwenden Sie den Onlinevorhersagedienst über ein Python-Skript:

  1. Erstellen Sie eine JSON-Datei mit dem Namen request.json für den Anfragetext.

    Sie müssen die Eingabe für die Onlinevorhersage mit den Details des Anfragetexts hinzufügen und formatieren, die der Zielcontainer erfordert.

  2. Installieren Sie die aktuelle Version der Vertex AI Platform-Clientbibliothek.

  3. Erforderliche Umgebungsvariablen in einem Python-Skript festlegen

  4. API-Anfrage authentifizieren

  5. Fügen Sie dem von Ihnen erstellten Python-Skript den folgenden Code hinzu:

    import json
import os
from typing import Sequence

import grpc
from absl import app
from absl import flags

from google.auth.transport import requests
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value
from google.cloud.aiplatform_v1.services import prediction_service

_INPUT = flags.DEFINE_string("input", None, "input", required=True)
_HOST = flags.DEFINE_string("host", None, "Prediction endpoint", required=True)
_ENDPOINT_ID = flags.DEFINE_string("endpoint_id", None, "endpoint id", required=True)

os.environ["GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"] = "path-to-ca-cert-file.cert"

# ENDPOINT_RESOURCE_NAME is a placeholder value that doesn't affect prediction behavior.
ENDPOINT_RESOURCE_NAME="projects/000000000000/locations/us-central1/endpoints/00000000000000"

def get_sts_token(host):
  creds = None
  try:
    creds, _ = google.auth.default()
    creds = creds.with_gdch_audience(host+":443")
    req = requests.Request()
    creds.refresh(req)
    print("Got token: ")
    print(creds.token)
  except Exception as e:
    print("Caught exception" + str(e))
    raise e
return creds.token

# predict_client_secure builds a client that requires TLS
def predict_client_secure(host, token):
  with open(os.environ["GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"], 'rb') as f:
    channel_creds = grpc.ssl_channel_credentials(f.read())

  call_creds = grpc.access_token_call_credentials(token)

  creds = grpc.composite_channel_credentials(
    channel_creds,
    call_creds,
  )

  client = prediction_service.PredictionServiceClient(
      transport=prediction_service.transports.grpc.PredictionServiceGrpcTransport(
       channel=grpc.secure_channel(target=host+":443", credentials=creds)))

  return client

def predict_func(client, instances):
  resp = client.predict(
    endpoint=ENDPOINT_RESOURCE_NAME,
    instances=instances,
    metadata=[("x-vertex-ai-endpoint-id", _ENDPOINT_ID.value)]
  )
  print(resp)

def main(argv: Sequence[str]):
  del argv  # Unused.
  with open(_INPUT.value) as json_file:
      data = json.load(json_file)
      instances = [json_format.ParseDict(s, Value()) for s in data["instances"]]

  token = get_sts_token(_HOST.value)
  client = predict_client_secure(_HOST.value, token)
  predict_func(client=client, instances=instances)

if __name__=="__main__":
  app.run(main)

  6. Speichern Sie das Python-Skript unter einem Namen, z. B. prediction.py.

  7. Anfrage an den Vorhersageserver senden:

    python SCRIPT_NAME --input request.json \
    --host ENDPOINT \
    --endpoint_id ENDPOINT_ID \

    Ersetzen Sie Folgendes:

    • SCRIPT_NAME: Der Name des Python-Skripts, z. B. prediction.py.
    • ENDPOINT: Ihr Modellendpunkt für die Onlinevorhersageanfrage.
    • ENDPOINT_ID: Der Wert der Endpunkt-ID.

Bei erfolgreicher Ausführung erhalten Sie eine JSON-Antwort auf Ihre Onlinevorhersageanfrage. Weitere Informationen zu Antworten finden Sie unter Details zum Antworttext.