Obtener una predicción online

El servicio de predicción online de Vertex AI te permite hacer solicitudes síncronas al endpoint de tu propio modelo de predicción.

En esta página se explica cómo enviar solicitudes a tu modelo para que pueda ofrecer predicciones online con baja latencia.

Antes de empezar

Para poder empezar a usar la API Online Prediction, debes tener un proyecto y las credenciales adecuadas.

Sigue estos pasos antes de obtener una predicción online:

  1. Configura un proyecto para Vertex AI.

  2. Para obtener los permisos que necesitas para acceder a Predicción online, pide al administrador de gestión de identidades y accesos de tu proyecto que te asigne el rol Usuario de predicción de Vertex AI (vertex-ai-prediction-user).

    Para obtener información sobre este rol, consulta Preparar permisos de gestión de identidades y accesos.

  3. Crea y entrena un modelo de predicción orientado a uno de los contenedores admitidos.

  4. Crea el clúster de predicción y asegúrate de que tu proyecto permita el tráfico externo entrante.

  5. Exporta los artefactos de tu modelo para la predicción.

  6. Despliega tu modelo en un endpoint.

  7. Muestra los detalles del recurso personalizado Endpoint de tu modelo de predicción:

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

    Haz los cambios siguientes:

    • PREDICTION_CLUSTER_KUBECONFIG: la ruta al archivo kubeconfig del clúster de predicción.
    • PREDICTION_ENDPOINT: el nombre del endpoint.
    • PROJECT_NAMESPACE: el nombre del espacio de nombres del proyecto de predicción.

    El resultado debe mostrar el campo status, que contiene el nombre de dominio completo del endpoint, en el campo endpointFQDN. Registre esta ruta de URL de endpoint para usarla en sus solicitudes.

Definir las variables de entorno

Si quieres enviar una solicitud al endpoint de tu modelo mediante una secuencia de comandos de Python y has configurado una cuenta de servicio en tu proyecto para hacer llamadas a la API autorizadas de forma programática, puedes definir variables de entorno en la secuencia de comandos para acceder a valores como las claves de la cuenta de servicio al ejecutarla.

Sigue estos pasos para definir las variables de entorno necesarias en una secuencia de comandos de Python:

  1. Crea un cuaderno de JupyterLab para interactuar con la API Online Prediction.

  2. Crea una secuencia de comandos de Python en el cuaderno de JupyterLab.

  3. Añade el siguiente código a la secuencia de comandos de Python:

    import os

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

    Sustituye APPLICATION_DEFAULT_CREDENTIALS_FILENAME por el nombre del archivo JSON que contiene las claves de la cuenta de servicio que has creado en el proyecto, como my-service-key.json.

  4. Guarda la secuencia de comandos de Python con un nombre, como prediction.py.

  5. Ejecuta la secuencia de comandos de Python para definir las variables de entorno:

    python SCRIPT_NAME

    Sustituye SCRIPT_NAME por el nombre que le hayas dado a tu script de Python, como prediction.py.

Enviar una solicitud a un endpoint

.

Envía una solicitud al endpoint del modelo para obtener una predicción online:

curl

Para hacer una solicitud de curl, sigue estos pasos:

  1. Crea un archivo JSON llamado request.json para el cuerpo de la solicitud.

    Debes añadir y dar formato a tu entrada para la predicción online con los detalles del cuerpo de la solicitud que el contenedor de destino requiera.

  2. Obtener un token de autenticación

  3. Haz la solicitud:

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

    Haz los cambios siguientes:

Si la solicitud se realiza correctamente, recibirás una respuesta JSON a tu solicitud de predicción online.

En el siguiente resultado se muestra un ejemplo:

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

Para obtener más información sobre las respuestas, consulta Detalles del cuerpo de la respuesta.

Python

Sigue estos pasos para usar el servicio de predicción online desde una secuencia de comandos de Python:

  1. Crea un archivo JSON llamado request.json para el cuerpo de la solicitud.

    Debes añadir y dar formato a tu entrada para la predicción online con los detalles del cuerpo de la solicitud que el contenedor de destino requiera.

  2. Instala la última versión de la biblioteca de cliente de la plataforma Vertex AI.

  3. Define las variables de entorno necesarias en una secuencia de comandos de Python.

  4. Autentica tu solicitud a la API.

  5. Añade el siguiente código a la secuencia de comandos de Python que has creado:

    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. Guarda la secuencia de comandos de Python con un nombre, como prediction.py.

  7. Envía la solicitud al servidor de predicción:

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

    Haz los cambios siguientes:

    • SCRIPT_NAME: el nombre de la secuencia de comandos de Python, como prediction.py.
    • ENDPOINT: el endpoint de tu modelo para la solicitud de predicción online.
    • ENDPOINT_ID: el valor del ID del endpoint.

Si la solicitud se realiza correctamente, recibirás una respuesta JSON a tu solicitud de predicción online. Para obtener más información sobre las respuestas, consulta Detalles del cuerpo de la respuesta.