Obtenha uma previsão online

O serviço de previsão online do Vertex AI permite-lhe fazer pedidos síncronos ao ponto final do seu próprio modelo de previsão.

Esta página mostra como enviar pedidos para o seu modelo para que possa publicar previsões online com baixa latência.

Antes de começar

Antes de poder começar a usar a API de previsão online, tem de ter um projeto e as credenciais adequadas.

Siga estes passos antes de receber uma previsão online:

  1. Configure um projeto para o Vertex AI.

  2. Para receber as autorizações de que precisa para aceder à previsão online, peça ao administrador de IAM do projeto para lhe conceder a função de utilizador de previsão do Vertex AI (vertex-ai-prediction-user).

    Para informações sobre esta função, consulte o artigo Prepare as autorizações de IAM.

  3. Crie e prepare um modelo de previsão com um dos contentores compatíveis como destino.

  4. Crie o cluster de previsão e certifique-se de que o seu projeto permite o tráfego externo recebido.

  5. Exporte os artefactos do modelo para a previsão.

  6. Implemente o modelo num ponto final.

  7. Mostre os detalhes do recurso personalizado Endpoint do modelo de previsão:

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

    Substitua o seguinte:

    • PREDICTION_CLUSTER_KUBECONFIG: o caminho para o ficheiro kubeconfig no cluster de previsão.
    • PREDICTION_ENDPOINT: o nome do ponto final.
    • PROJECT_NAMESPACE: o nome do espaço de nomes do projeto de previsão.

    O resultado tem de mostrar o campo status, apresentando o nome de domínio totalmente qualificado do ponto final no campo endpointFQDN. Registe este caminho do URL do ponto final para o usar nos seus pedidos.

Defina as variáveis de ambiente

Se quiser enviar um pedido para o ponto final do modelo através de um script Python e configurar uma conta de serviço no seu projeto para fazer chamadas à API autorizadas de forma programática, pode definir variáveis de ambiente no script para aceder a valores como as chaves da conta de serviço durante a execução.

Siga estes passos para definir as variáveis de ambiente necessárias num script Python:

  1. Crie um notebook JupyterLab para interagir com a API de previsão online.

  2. Crie um script Python no notebook JupyterLab.

  3. Adicione o seguinte código ao script Python:

    import os

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

    Substitua APPLICATION_DEFAULT_CREDENTIALS_FILENAME por o nome do ficheiro JSON que contém as chaves da conta de serviço que criou no projeto, como my-service-key.json.

  4. Guarde o script Python com um nome, como prediction.py.

  5. Execute o script Python para definir as variáveis de ambiente:

    python SCRIPT_NAME

    Substitua SCRIPT_NAME pelo nome que deu ao script Python, como prediction.py.

Envie um pedido para um ponto final

Faça um pedido ao ponto final do modelo para receber uma previsão online:

curl

Siga estes passos para fazer um pedido curl:

  1. Crie um ficheiro JSON denominado request.json para o corpo do pedido.

    Tem de adicionar e formatar a sua entrada para a previsão online com os detalhes do corpo do pedido que o contentor de destino requer.

  2. Receba um token de autenticação.

  3. Faça o pedido:

    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

    Substitua o seguinte:

    • TOKEN: o token de autenticação que recebeu.
    • ENDPOINT_HOSTNAME: o FQDN do ponto final do modelo para o pedido de previsão online.

Se for bem-sucedido, recebe uma resposta JSON ao seu pedido de previsão online.

O resultado seguinte mostra um exemplo:

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

Para mais informações sobre as respostas, consulte o artigo Detalhes do corpo da resposta.

Python

Siga estes passos para usar o serviço de previsão online a partir de um script Python:

  1. Crie um ficheiro JSON denominado request.json para o corpo do pedido.

    Tem de adicionar e formatar a sua entrada para a previsão online com os detalhes do corpo do pedido que o contentor de destino requer.

  2. Instale a versão mais recente da biblioteca de cliente da plataforma Vertex AI.

  3. Defina as variáveis de ambiente necessárias num script Python.

  4. Autentique o seu pedido de API.

  5. Adicione o seguinte código ao script Python que criou:

    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. Guarde o script Python com um nome, como prediction.py.

  7. Faça o pedido ao servidor de previsão:

    python SCRIPT_NAME --input request.json \
    --endpoint_hostname ENDPOINT_FQDN \
    --project_name PROJECT_NAME \
    --endpoint_name ENDPOINT_NAME \

    Substitua o seguinte:

    • SCRIPT_NAME: o nome do script Python, como prediction.py.
    • ENDPOINT_FQDN: o nome de domínio totalmente qualificado do ponto final para o pedido de previsão online.
    • PROJECT_NAME: o nome do projeto do ponto final.
    • ENDPOINT_NAME: o nome do ponto final a chamar.

Se for bem-sucedido, recebe uma resposta JSON ao seu pedido de previsão online. Para mais informações sobre as respostas, consulte o artigo Detalhes do corpo da resposta.