Receber uma previsão on-line

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

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

Antes de começar

Antes de começar a usar a API Online Prediction, você precisa 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ê a função de usuário de previsão da Vertex AI (vertex-ai-prediction-user).

    Para 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 seu 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 de URL do endpoint para usá-lo nas suas 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 seu 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 Online Prediction.

  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 pelo 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 do 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 do 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.

    É necessário adicionar e formatar sua entrada para previsão on-line com os detalhes do corpo da solicitação que o contêiner de destino exige.

  2. Receber 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:443/v1/model:predict -d @request.json

    Substitua:

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

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

Confira um exemplo da saída:

{
    "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 predição on-line em um script Python:

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

    É necessário adicionar e formatar sua entrada para previsão on-line com os detalhes do corpo da solicitação que o contêiner de destino exige.

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

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

  4. Autentique sua solicitação de API.

  5. Adicione o seguinte código ao script Python que você 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. Salve o script do Python com um nome, como prediction.py.

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

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

    Substitua:

    • SCRIPT_NAME: o nome do script Python, como prediction.py.
    • ENDPOINT: o endpoint do modelo para a solicitação de previsão on-line.
    • ENDPOINT_ID: o valor do ID do endpoint.

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