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.

Prima di ricevere una previsione online, segui questi passaggi:

  1. Configura un progetto per Vertex AI.

  2. Per ottenere le autorizzazioni necessarie per accedere alla previsione online, chiedi all'amministratore IAM del progetto di concederti il ruolo Utente previsione Vertex AI (vertex-ai-prediction-user).

    Per informazioni su questo ruolo, consulta Preparare 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 dell'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 assegnato 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 inviare 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 che il contenitore di destinazione richiede.

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

    Sostituisci quanto segue:

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

L'output seguente mostra un esempio:

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

Per ulteriori informazioni sulle risposte, consulta 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 che il contenitore di destinazione richiede.

  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

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

  7. Effettua la richiesta al server di previsione:

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

    Sostituisci quanto segue:

    • SCRIPT_NAME: il nome dello script Python, ad esempio prediction.py.
    • ENDPOINT: l'endpoint del modello per la richiesta di previsione online.
    • ENDPOINT_ID: il valore dell'ID endpoint.

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