Ricevere una previsione online

Il servizio di previsione online di Vertex AI consente di effettuare richieste sincrone all'endpoint del modello di previsione.

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

Prima di iniziare

Prima di poter iniziare a utilizzare l'API Prediction online, devi avere un progetto e le 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 alla previsione online, chiedi all'amministratore IAM del progetto di concederti il ruolo Utente di previsione di Vertex AI (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 dell'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 account di servizio nel tuo progetto per effettuare chiamate API autorizzate a livello programmatico, puoi definire le variabili di ambiente nello script per accedere a valori come le chiavi dell'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 Prediction online.

  2. Crea uno script Python nel notebook JupyterLab.

  3. Aggiungi il codice seguente 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 contenente 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

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

curl

Segui questi passaggi per effettuare una richiesta 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 da container di destinazione.

  2. Ottieni 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.

In caso di esito positivo, riceverai una risposta JSON alla tua richiesta di previsione online.

L'output seguente mostra un esempio:

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

Per saperne di più sulle risposte, consulta Dettagli del corpo della risposta.

Python

Segui questi passaggi 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 da 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 codice seguente 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. Effettua 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.

In caso di esito positivo, riceverai una risposta JSON alla tua richiesta di previsione online. Per saperne di più sulle risposte, consulta Dettagli del corpo della risposta.