Receber uma previsão on-line

O serviço de previsão on-line da Vertex AI permite fazer solicitações síncronas para o endpoint do modelo de previsão.

Nesta página, mostramos como enviar solicitações ao modelo para que ele possa disponibilizar previsões on-line com baixa latência.

Antes de começar

Antes de começar a usar a API Prediction on-line, é preciso ter um projeto e as credenciais adequadas.

Siga estas etapas antes de receber uma previsão on-line:

  1. Configure um projeto para a Vertex AI.

  2. Para receber as permissões necessárias para acessar a previsão on-line, peça ao administrador do IAM do projeto para conceder a você o papel de usuário de previsão da Vertex AI (vertex-ai-prediction-user).

    Para mais informações sobre esse papel, consulte Preparar permissões do IAM.

  3. Crie e treine um modelo de previsão direcionado a um dos contêineres compatíveis.

  4. Crie o cluster de previsão e verifique se o projeto permite tráfego externo de entrada.

  5. Exporte os artefatos do modelo para previsão.

  6. Implante o modelo em um endpoint.

  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:

    • PREDICTION_CLUSTER_KUBECONFIG: o caminho para o arquivo kubeconfig no cluster de previsão.
    • PREDICTION_ENDPOINT: o nome do endpoint.
    • PROJECT_NAMESPACE: o nome do namespace do projeto de previsão.

    A saída precisa mostrar o campo status, exibindo o nome de domínio totalmente qualificado do endpoint no campo endpointFQDN. Registre esse caminho do URL do endpoint para usá-lo nas solicitações.

Definir as variáveis de ambiente

Se você quiser enviar uma solicitação ao endpoint do modelo usando um script Python e configurar uma conta de serviço no projeto para fazer chamadas de API autorizadas de maneira programática, defina variáveis de ambiente no script para acessar valores como as chaves da conta de serviço durante a execução.

Siga estas etapas para definir as variáveis de ambiente necessárias em um script Python:

  1. Crie um notebook do JupyterLab para interagir com a API Prediction on-line.

  2. Crie um script Python no notebook 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 por o nome do arquivo JSON que contém as chaves da conta de serviço criadas no projeto, como my-service-key.json.

  4. Salve 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 você deu ao script Python, como prediction.py.

Enviar uma solicitação para um endpoint

Faça uma solicitação ao endpoint do modelo para receber uma previsão on-line:

curl

Siga estas etapas para fazer uma solicitação curl:

  1. Crie um arquivo JSON chamado request.json para o corpo da solicitação.

    Adicione e formate a entrada para previsão on-line com os detalhes do corpo da solicitação exigidos pelocontêiner de destino.

  2. Receba um token de autenticação.

  3. Faça a solicitação:

    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:

    • TOKEN: o token de autenticação que você recebeu.
    • ENDPOINT_HOSTNAME: o FQDN do endpoint do modelo para a solicitação de previsão on-line.

Se for bem-sucedido, você vai receber uma resposta JSON à solicitação de previsão on-line.

A saída a seguir mostra um exemplo:

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

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

Python

Siga estas etapas para usar o serviço de previsão on-line de um script Python:

  1. Crie um arquivo JSON chamado request.json para o corpo da solicitação.

    Adicione e formate a entrada para previsão on-line com os detalhes do corpo da solicitação exigidos pelocontêiner de destino.

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

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

  4. Autentique a solicitação de API.

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

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

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

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

    Substitua:

    • SCRIPT_NAME: o nome do script Python, como prediction.py.
    • ENDPOINT_FQDN: o nome de domínio totalmente qualificado do endpoint para a solicitação de previsão on-line.
    • PROJECT_NAME: o nome do projeto do endpoint.
    • ENDPOINT_NAME: o nome do endpoint a ser chamado.

Se for bem-sucedido, você vai receber uma resposta JSON à solicitação de previsão on-line. Para mais informações sobre respostas, consulte Detalhes do corpo da resposta.