Obtener una predicción online

El servicio de predicción online de Vertex AI te permite enviar 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 usar la API de predicción online, 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 la predicción online, pide a tu administrador de IAM del proyecto que te asigne el rol de usuario de predicción de Vertex AI (vertex-ai-prediction-user).

    Para obtener información sobre este rol, consulta el artículo Preparar permisos de IAM.

  3. Crea y entrena un modelo de predicción que esté 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: ruta al archivo kubeconfig del clúster de predicción.
    • PREDICTION_ENDPOINT: nombre del endpoint.
    • PROJECT_NAMESPACE: nombre del espacio de nombres del proyecto de predicción.

    En el resultado debe mostrarse el campo status, que contiene el nombre de dominio completo del endpoint en el campo endpointFQDN. Registra esta ruta de URL del endpoint para usarla en tus solicitudes.

Definir 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 durante la ejecución.

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 de predicción online.

  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 has dado a tu secuencia de comandos 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

Sigue estos pasos para enviar una solicitud curl:

  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 requiere el contenedor de destino.

  2. Obtén un token de autenticación.

  3. Envía la solicitud:

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

    Haz los cambios siguientes:

    • TOKEN: el token de autenticación que has obtenido.
    • ENDPOINT_HOSTNAME: nombre de dominio completo del endpoint de tu modelo para la solicitud de predicción online.

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

A continuación, se muestra un ejemplo:

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

Para obtener más información sobre las respuestas, consulta el artículo 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 requiere el contenedor de destino.

  2. Instala la versión más reciente de la biblioteca de cliente de Vertex AI Platform.

  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
import google

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)
_ENDPOINT_HOSTNAME = flags.DEFINE_string("endpoint_hostname", None, "Prediction endpoint FQDN", required=True)
_PROJECT_NAME = flags.DEFINE_string("project_name", None, "project name", required=True)
_ENDPOINT_NAME = flags.DEFINE_string("endpoint_name", None, "endpoint name", required=True)

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

def get_sts_token(endpoint_hostname):
  creds = None
  try:
    creds, _ = google.auth.default()
    creds = creds.with_gdch_audience("https://"+endpoint_hostname+":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(endpoint_hostname, 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=endpoint_hostname+":443", credentials=creds)))

  return client

def predict_func(client, instances):
  # The endpoint resource name is required for authorization.
  # A wrong value might lead to an access denied error.
  endpoint_resource_name = f"projects/{_PROJECT_NAME.value}/locations/{_PROJECT_NAME.value}/endpoints/{_ENDPOINT_NAME.value}"
  resp = client.predict(
    endpoint=endpoint_resource_name,
    instances=instances,
    metadata=[("x-vertex-ai-endpoint-id", _ENDPOINT_NAME.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(_ENDPOINT_HOSTNAME.value)
  client = predict_client_secure(_ENDPOINT_HOSTNAME.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 \
    --endpoint_hostname ENDPOINT_FQDN \
    --project_name PROJECT_NAME \
    --endpoint_name ENDPOINT_NAME \

    Haz los cambios siguientes:

    • SCRIPT_NAME: nombre de la secuencia de comandos de Python, como prediction.py.
    • ENDPOINT_FQDN: nombre de dominio completo del endpoint para la solicitud de predicción online.
    • PROJECT_NAME: nombre del proyecto del endpoint.
    • ENDPOINT_NAME: nombre del endpoint al que se va a llamar.

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 el artículo Detalles del cuerpo de la respuesta.