Ricevere una previsione online

Il servizio di previsione online di Vertex AI ti consente di effettuare richieste sincrone al tuo endpoint del modello di previsione.

Questa pagina mostra come inviare richieste al modello in modo che possa fornire previsioni online con bassa latenza.

Prima di iniziare

Prima di poter iniziare a utilizzare l'API Online Prediction, devi disporre di un progetto e delle credenziali appropriate.

Segui questi passaggi prima di ottenere una previsione online:

  1. Configura un progetto per Vertex AI.

  2. Per ottenere le autorizzazioni necessarie per accedere a Online Prediction, chiedi all'amministratore IAM del progetto di concederti il ruolo Vertex AI Prediction User (vertex-ai-prediction-user).

    Per informazioni su questo ruolo, consulta Prepara le autorizzazioni IAM.

  3. Crea e addestra un modello di previsione che abbia come target uno dei container supportati.

  4. Crea il cluster di previsione e assicurati che il tuo progetto consenta il traffico esterno in entrata.

  5. Esporta gli artefatti del modello per la previsione.

  6. Esegui il deployment del modello su un endpoint.

  7. Mostra i dettagli della risorsa personalizzata Endpoint del modello di previsione:

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

    Sostituisci quanto segue:

    • PREDICTION_CLUSTER_KUBECONFIG: il percorso del file kubeconfig nel cluster di previsione.
    • PREDICTION_ENDPOINT: il nome dell'endpoint.
    • PROJECT_NAMESPACE: il nome dello spazio dei nomi del progetto di previsione.

    L'output deve mostrare il campo status, che visualizza il nome di dominio completo dell'endpoint nel campo endpointFQDN. Registra questo percorso URL dell'endpoint per utilizzarlo per le tue richieste.

Imposta le variabili di ambiente

Se vuoi inviare una richiesta all'endpoint del modello utilizzando uno script Python e hai configurato un service account nel tuo progetto per effettuare chiamate API autorizzate a livello di programmazione, puoi definire variabili di ambiente nello script per accedere a valori come le chiavi del account di servizio durante l'esecuzione.

Segui questi passaggi per impostare le variabili di ambiente richieste in uno script Python:

  1. Crea un notebook JupyterLab per interagire con l'API Online Prediction.

  2. Crea uno script Python nel notebook JupyterLab.

  3. Aggiungi il seguente codice allo script Python:

    import os

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

    Sostituisci APPLICATION_DEFAULT_CREDENTIALS_FILENAME con il nome del file JSON che contiene le chiavi account di servizio che hai creato nel progetto, ad esempio my-service-key.json.

  4. Salva lo script Python con un nome, ad esempio prediction.py.

  5. Esegui lo script Python per impostare le variabili di ambiente:

    python SCRIPT_NAME

    Sostituisci SCRIPT_NAME con il nome che hai dato allo script Python, ad esempio prediction.py.

Invia una richiesta a un endpoint

Invia una richiesta all'endpoint del modello per ottenere una previsione online:

curl

Segui questi passaggi per effettuare una richiesta di curl:

  1. Crea un file JSON denominato request.json per il corpo della richiesta.

    Devi aggiungere e formattare l'input per la previsione online con i dettagli del corpo della richiesta richiesti dal container di destinazione.

  2. Ottenere un token di autenticazione.

  3. Effettua la richiesta:

    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

    Sostituisci quanto segue:

    • TOKEN: il token di autenticazione che hai ottenuto.
    • ENDPOINT_HOSTNAME: il nome di dominio completo dell'endpoint del modello per la richiesta di previsione online.

Se l'operazione ha esito positivo, ricevi una risposta JSON alla tua richiesta di previsione online.

Il seguente output mostra un esempio:

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

Per ulteriori informazioni sulle risposte, consulta la sezione Dettagli del corpo della risposta.

Python

Per utilizzare il servizio di previsione online da uno script Python:

  1. Crea un file JSON denominato request.json per il corpo della richiesta.

    Devi aggiungere e formattare l'input per la previsione online con i dettagli del corpo della richiesta richiesti dal container di destinazione.

  2. Installa l'ultima versione della libreria client di Vertex AI Platform.

  3. Imposta le variabili di ambiente richieste in uno script Python.

  4. Autentica la richiesta API.

  5. Aggiungi il seguente codice allo script Python che hai creato:

    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. Salva lo script Python con un nome, ad esempio prediction.py.

  7. Invia la richiesta al server di previsione:

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

    Sostituisci quanto segue:

    • SCRIPT_NAME: il nome dello script Python, ad esempio prediction.py.
    • ENDPOINT_FQDN: il nome di dominio completo dell'endpoint per la richiesta di previsione online.
    • PROJECT_NAME: il nome del progetto dell'endpoint.
    • ENDPOINT_NAME: il nome dell'endpoint da chiamare.

Se l'operazione ha esito positivo, ricevi una risposta JSON alla tua richiesta di previsione online. Per ulteriori informazioni sulle risposte, consulta la sezione Dettagli del corpo della risposta.