Obtenha uma previsão online

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

Esta página mostra como enviar pedidos ao 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 Online Prediction, tem de ter um projeto e credenciais adequadas.

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

  1. Configure um projeto para o Vertex AI.

  2. Para receber as autorizações necessárias 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 que segmente um dos contentores suportados.

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

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

  6. Implemente o seu modelo num ponto final.

  7. Mostrar detalhes do recurso personalizado Endpoint do seu 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 seu modelo através de um script Python e configurar uma conta de serviço no seu projeto para fazer chamadas de 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 do JupyterLab para interagir com a API Online Prediction.

  2. Crie um script Python no bloco de notas do 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 pelo 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 seu script Python, como prediction.py.

Envie um pedido para um ponto final

Faça um pedido ao ponto final do modelo para obter 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. Obtenha 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:443/v1/model:predict -d @request.json

    Substitua o seguinte:

Se tiver êxito, 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 os 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 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

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. 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 \
    --host ENDPOINT \
    --endpoint_id ENDPOINT_ID \

    Substitua o seguinte:

    • SCRIPT_NAME: o nome do script Python, como prediction.py.
    • ENDPOINT: o seu ponto final do modelo para o pedido de previsão online.
    • ENDPOINT_ID: o valor do ID do ponto final.

Se tiver êxito, recebe uma resposta JSON ao seu pedido de previsão online. Para mais informações sobre as respostas, consulte os detalhes do corpo da resposta.