Gestione delle previsioni con NVIDIA Triton

In questa pagina viene descritto come gestire le richieste di previsione con il server di inferenza NVIDIA Triton utilizzando Vertex AI Prediction. Il server di inferenza NVIDIA Triton (Triton) è una soluzione di gestione di inferenza open source di NVIDIA ottimizzata per CPU e GPU, che semplifica il processo di pubblicazione dell'inferenza.

NVIDIA Triton su Vertex AI Prediction

Vertex AI Prediction supporta il deployment di modelli su server di inferenza Triton in esecuzione su un container personalizzato pubblicato da NVIDIA GPU Cloud (NGC) - Immagine server di inferenza NVIDIA Triton. Le immagini Triton di NVIDIA dispongono di tutti i pacchetti e le configurazioni richieste che soddisfano i requisiti di Vertex AI per le immagini container di pubblicazione personalizzate. L'immagine contiene il server di inferenza Triton con supporto per i modelli TensorFlow, PyTorch, TensorRT, ONNX e OpenVINO. L'immagine include anche il backend FIL (Forest Inference Library) che supporta l'esecuzione di framework ML come XGBoost, LightGBM e Scikit-Learn.

Triton carica i modelli e espone gli endpoint REST di inferenza, integrità e gestione dei modelli che utilizzano i protocolli di inferenza standard. Durante il deployment di un modello in Vertex AI, Triton riconosce gli ambienti Vertex AI e adotta il protocollo di previsione Vertex AI per i controlli di integrità e le richieste di previsione.

L'elenco seguente illustra le funzionalità principali e i casi d'uso del server di inferenza NVIDIA Triton:

• Supporto per più framework di deep learning e machine learning: Triton supporta il deployment di più modelli e di una combinazione di framework e formati di modelli, come TensorFlow (saveModel e GraphDef), PyTorch (TorchScript), TensorRT, ONNX, OpenVINO e FIL per supportare framework come XGBoost, LightGBM, Scikit-Learn+ e formati personalizzati.
• Esecuzione simultanea di più modelli: Triton consente di eseguire contemporaneamente più modelli, più istanze dello stesso modello o entrambi sulla stessa risorsa di computing con zero o più GPU.
• Ensembleing di modelli (concatenamento o pipeline). L'ensemble di Triton supporta casi d'uso in cui più modelli sono composti come pipeline (o DAG, Grafico aciclico diretto) con input e tensori di output collegati tra loro. Inoltre, con un backend Triton Python, puoi includere qualsiasi logica di flusso di pre-elaborazione, post-elaborazione o di controllo definita dal Business Logic Scripting (BLS).
• Esecuzione su backend di CPU e GPU: Triton supporta l'inferenza per i modelli di cui è stato eseguito il deployment su nodi con CPU e GPU.
• Batch dinamico delle richieste di previsione: per i modelli che supportano il batch, Triton dispone di algoritmi di pianificazione e batch integrati. Questi algoritmi combinano dinamicamente le singole richieste di inferenza in batch sul lato server per migliorare la velocità effettiva di inferenza e aumentare l'utilizzo della GPU.

Per ulteriori informazioni sul server di inferenza NVIDIA Triton, consulta la documentazione di Triton.

Immagini container NVIDIA Triton disponibili

La tabella seguente mostra le immagini Docker di Triton disponibili nel catalogo di NVIDIA NGC. Scegli un'immagine in base al framework del modello, al backend e alle dimensioni dell'immagine container che utilizzi.

xx e yy si riferiscono rispettivamente alle versioni principali e secondarie di Triton.

Immagine NVIDIA Triton	Supporti
xx.yy-py3	Container completo con supporto per i modelli TensorFlow, PyTorch, TensorRT, ONNX e OpenVINO
xx.yy-pyt-python-py3	Solo backend PyTorch e Python
xx.yy-tf2-python-py3	Solo backend TensorFlow 2.x e Python
xx.yy-py3-min	Personalizza il container Triton in base alle esigenze

Per iniziare: pubblicazione delle previsioni con NVIDIA Triton

La figura seguente mostra l'architettura di alto livello di Triton su Vertex AI Prediction:

• Un modello ML gestito da Triton è registrato in Vertex AI Model Registry. I metadati del modello fanno riferimento a una posizione degli artefatti del modello in Cloud Storage, al container di pubblicazione personalizzato e alla sua configurazione.
• Il modello di Vertex AI Model Registry viene sottoposto a deployment su un endpoint di previsione Vertex AI che esegue il server di inferenza Triton come container personalizzato su nodi di computing con CPU e GPU.
• Le richieste di inferenza arrivano al server di inferenza Triton tramite un endpoint di Vertex AI Prediction e instradate allo scheduler appropriato.
• Il backend esegue l'inferenza utilizzando gli input forniti nelle richieste in batch e restituisce una risposta.
• Triton fornisce endpoint per l'idoneità e l'integrità dell'attività, che consentono l'integrazione di Triton in ambienti di deployment come Vertex AI Prediction.

Questo tutorial mostra come utilizzare un container personalizzato che esegue il server di inferenza NVIDIA Triton per eseguire il deployment di un modello di machine learning (ML) su Vertex AI Prediction, che fornisce previsioni online. Esegui il deployment di un container che esegue Triton per fornire previsioni da un modello di rilevamento di oggetti di TensorFlow Hub preaddestrato sul set di dati COCO 2017. Puoi quindi utilizzare Vertex AI Prediction per rilevare gli oggetti in un'immagine.

Puoi anche eseguire il tutorial su Vertex AI Workbench seguendo questo blocco note Jupyter.

Nota: il blocco note Jupyter utilizza l'SDK Vertex AI per Python. Questo tutorial esegue i comandi di gcloud ai.

Prima di iniziare

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Abilita le API Vertex AI API and Artifact Registry API.

   Abilita le API

5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

7. Abilita le API Vertex AI API and Artifact Registry API.

   Abilita le API

8. Nella console Google Cloud, attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

Durante questo tutorial, ti consigliamo di utilizzare Cloud Shell per interagire con Google Cloud. Se vuoi utilizzare una shell Bash diversa invece di Cloud Shell, esegui la seguente configurazione aggiuntiva:

1. Installa Google Cloud CLI.

2. Per initialize gcloud CLI, esegui questo comando:

   gcloud init

3. Segui la documentazione di Artifact Registry per installare Docker.

Creazione ed esecuzione del push dell'immagine container

Per utilizzare un container personalizzato, devi specificare un'immagine container Docker che soddisfi i requisiti per i container personalizzati. Questa sezione descrive come creare l'immagine container ed eseguirne il push in Artifact Registry.

Scarica artefatti del modello

Gli artefatti del modello sono file creati dall'addestramento ML che puoi utilizzare per fornire previsioni. Contengono, come minimo, la struttura e le ponderazioni del modello ML addestrato. Il formato degli artefatti del modello dipende dal framework ML che usi per l'addestramento.

Per questo tutorial, anziché addestrare un modello da zero, scarica il modello di rilevamento degli oggetti da TensorFlow Hub addestrato sul set di dati COCO 2017. Triton prevede che il repository di modelli sarà organizzato nella seguente struttura per fornire il formato TensorFlow SavedModel:

└── model-repository-path
       └── model_name
              ├── config.pbtxt
              └── 1
                  └── model.savedmodel
                        └── <saved-model-files>

Il file config.pbtxt descrive la configurazione del modello per il modello. Per impostazione predefinita, deve essere fornito il file di configurazione del modello che contiene le impostazioni richieste. Tuttavia, se Triton viene avviato con l'opzione --strict-model-config=false, in alcuni casi la configurazione del modello può essere generata automaticamente da Triton e non deve essere fornita esplicitamente. In particolare, i modelli TensorRT, TensorFlow SavingModel e ONNX non richiedono un file di configurazione del modello perché Triton può ricavare automaticamente tutte le impostazioni richieste. Tutti gli altri tipi di modelli devono fornire un file di configurazione del modello.

# Download and organize model artifacts according to the Triton model repository spec
mkdir -p models/object_detector/1/model.savedmodel/
curl -L "https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1?tf-hub-format=compressed" | \
    tar -zxvC ./models/object_detector/1/model.savedmodel/
ls -ltr ./models/object_detector/1/model.savedmodel/

Dopo aver scaricato il modello in locale, il repository dei modelli verrà organizzato come segue:

./models
└── object_detector
    └── 1
        └── model.savedmodel
            ├── saved_model.pb
            └── variables
                ├── variables.data-00000-of-00001
                └── variables.index

Copia gli artefatti del modello in un bucket Cloud Storage

Gli artefatti del modello scaricati, incluso il file di configurazione del modello, vengono inviati tramite push a un bucket Cloud Storage specificato da MODEL_ARTIFACTS_REPOSITORY, che può essere utilizzato quando crei la risorsa del modello Vertex AI.

gsutil cp -r ./models/object_detector MODEL_ARTIFACTS_REPOSITORY/

Crea un repository Artifact Registry

Crea un repository Artifact Registry per archiviare l'immagine container che creerai nella sezione successiva.

Abilita il servizio API Artifact Registry per il tuo progetto.

gcloud services enable artifactregistry.googleapis.com

Esegui questo comando nella shell per creare un repository Artifact Registry:

gcloud artifacts repositories create getting-started-nvidia-triton \
 --repository-format=docker \
 --location=LOCATION \
 --description="NVIDIA Triton Docker repository"

Sostituisci LOCATION con la regione in cui Artifact Registry archivia l'immagine container. Successivamente, dovrai creare una risorsa del modello Vertex AI su un endpoint a livello di regione che corrisponda a questa regione, quindi scegli una regione in cui Vertex AI abbia un endpoint a livello di regione, ad esempio us-central1.

Dopo aver completato l'operazione, il comando stampa il seguente output:

Created repository [getting-started-nvidia-triton].

Crea l'immagine container

NVIDIA fornisce immagini Docker per creare un'immagine container che esegue Triton e in linea con i requisiti per i container personalizzati di Vertex AI per la pubblicazione. Puoi eseguire il pull dell'immagine utilizzando docker e taggare il percorso di Artifact Registry su cui verrà eseguito il push dell'immagine.

NGC_TRITON_IMAGE_URI="nvcr.io/nvidia/tritonserver:22.01-py3"
docker pull $NGC_TRITON_IMAGE_URI
docker tag $NGC_TRITON_IMAGE_URI LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference

Sostituisci quanto segue:

• LOCATION: la regione del repository Artifact Registry, come specificato in una sezione precedente
• PROJECT_ID: l'ID del tuo progetto Google Cloud

Il comando potrebbe essere eseguito per diversi minuti.

Prepara il file del payload per il test delle richieste di previsione

Per inviare una richiesta di previsione al server del container, prepara il payload con un file immagine di esempio che utilizza Python. Esegui il seguente script Python per generare il file di payload:

import json
import requests

# install required packages before running
# pip install pillow numpy --upgrade
from PIL import Image
import numpy as np

# method to generate payload from image url
def generate_payload(image_url):
    # download image from url and resize
    image_inputs = Image.open(requests.get(image_url, stream=True).raw)
    image_inputs = image_inputs.resize((200, 200))

    # convert image to numpy array
    image_tensor = np.asarray(image_inputs)
    # derive image shape
    image_shape = [1] + list(image_tensor.shape)

    # create payload request
    payload = {
        "id": "0",
        "inputs": [
            {
                "name": "input_tensor",
                "shape": image_shape,
                "datatype": "UINT8",
                "parameters": {},
                "data": image_tensor.tolist(),
            }
        ],
    }

    # save payload as json file
    payload_file = "instances.json"
    with open(payload_file, "w") as f:
        json.dump(payload, f)
    print(f"Payload generated at {payload_file}")

    return payload_file

if __name__ == '__main__':
  image_url = "https://github.com/tensorflow/models/raw/master/research/object_detection/test_images/image2.jpg"
  payload_file = generate_payload(image_url)

Lo script Python genera il payload e stampa la seguente risposta:

Payload generated at instances.json

Esegui il container localmente (facoltativo)

Prima di eseguire il push dell'immagine container ad Artifact Registry per utilizzarla con Vertex AI Prediction, puoi eseguirla come container nel tuo ambiente locale per verificare che il server funzioni come previsto:

1. Per eseguire l'immagine container localmente, esegui questo comando nella shell:

   docker run -t -d -p 8000:8000 --rm \
     --name=local_object_detector \
     -e AIP_MODE=True \
     LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference \
     --model-repository MODEL_ARTIFACTS_REPOSITORY \
     --strict-model-config=false
   

   Sostituisci quanto segue, come hai fatto nella sezione precedente:

   • LOCATION: la regione del repository Artifact Registry, come specificato in una sezione precedente
   • PROJECT_ID: l'ID del tuo progetto Google Cloud
   • MODEL_ARTIFACTS_REPOSITORY: il percorso di Cloud Storage in cui si trovano gli artefatti del modello

   Questo comando esegue un container in modalità scollegata, mappando la porta 8000 del container alla porta 8000 dell'ambiente locale. L'immagine Triton di NGC configura Triton per l'utilizzo della porta 8000.

2. Per inviare un controllo di integrità al server del container, esegui questo comando nella shell:

   curl -s -o /dev/null -w "%{http_code}" http://localhost:8000/v2/health/ready
   

   In caso di esito positivo, il server restituisce il codice di stato come 200.

3. Esegui questo comando per inviare al server del container una richiesta di previsione utilizzando il payload generato in precedenza e ottenere le risposte di previsione:

   curl -X POST \
     -H "Content-Type: application/json" \
     -d @instances.json \
     localhost:8000/v2/models/object_detector/infer |
   jq -c '.outputs[] | select(.name == "detection_classes")'
   

   Questa richiesta utilizza una delle immagini di test incluse nell'esempio di rilevamento degli oggetti TensorFlow.

   In caso di esito positivo, il server restituisce la seguente previsione:

   {"name":"detection_classes","datatype":"FP32","shape":[1,300],"data":[38,1,...,44]}
   

4. Per arrestare il container, esegui questo comando nella shell:

   docker stop local_object_detector
   

Esegui il push dell'immagine container in Artifact Registry

Configura Docker per accedere ad Artifact Registry. Poi esegui il push dell'immagine container nel repository Artifact Registry.

1. Per concedere all'installazione Docker locale l'autorizzazione per eseguire il push ad Artifact Registry nella regione che hai scelto, esegui questo comando nella shell:

   gcloud auth configure-docker LOCATION-docker.pkg.dev
   

   • Sostituisci LOCATION con la regione in cui hai creato il repository in una sezione precedente.

2. Per eseguire il push dell'immagine container che hai appena creato in Artifact Registry, esegui il comando seguente nella shell:

   docker push LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference
   

   Sostituisci quanto segue, come hai fatto nella sezione precedente:

   • LOCATION: la regione del repository Artifact Registry, come specificato in una sezione precedente
   • PROJECT_ID: l'ID del tuo progetto Google Cloud

Deployment del modello

Crea un modello

Per creare una risorsa Model che utilizza un container personalizzato che esegue Triton, esegui il seguente comando gcloud ai models upload:

gcloud ai models upload \
  --region=LOCATION \
  --display-name=DEPLOYED_MODEL_NAME \
  --container-image-uri=LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference \
  --artifact-uri=MODEL_ARTIFACTS_REPOSITORY \
  --container-args='--strict-model-config=false'

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• PROJECT_ID: l'ID del tuo progetto Google Cloud
• DEPLOYED_MODEL_NAME: un nome per DeployedModel. Puoi utilizzare anche il nome visualizzato di Model per DeployedModel.

L'argomento --container-args='--strict-model-config=false' consente a Triton di generare automaticamente la configurazione del modello.

Crea un endpoint

Devi eseguire il deployment del modello su un endpoint prima che possa essere utilizzato per fornire previsioni online. Se esegui il deployment di un modello in un endpoint esistente, puoi saltare questo passaggio. L'esempio seguente utilizza il comando gcloud ai endpoints create:

gcloud ai endpoints create \
  --region=LOCATION \
  --display-name=ENDPOINT_NAME

Sostituisci quanto segue:

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Lo strumento Google Cloud CLI potrebbe richiedere alcuni secondi per creare l'endpoint.

Esegui il deployment del modello nell'endpoint

Quando l'endpoint è pronto, esegui il deployment del modello sull'endpoint. Quando esegui il deployment di un modello in un endpoint, il servizio associa le risorse fisiche al modello che esegue Triton per fornire previsioni online.

L'esempio seguente utilizza il comando gcloud ai endpoints deploy-model per eseguire il deployment di Model su un Triton endpoint in esecuzione sulle GPU per accelerare la fornitura della previsione e senza suddividere il traffico tra più risorse DeployedModel:

ENDPOINT_ID=$(gcloud ai endpoints list \
   --region=LOCATION \
   --filter=display_name=ENDPOINT_NAME \
   --format="value(name)")

MODEL_ID=$(gcloud ai models list \
   --region=LOCATION \
   --filter=display_name=DEPLOYED_MODEL_NAME \
   --format="value(name)")

gcloud ai endpoints deploy-model $ENDPOINT_ID \
  --region=LOCATION \
  --model=$MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --machine-type=MACHINE_TYPE \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --accelerator=count=ACCELERATOR_COUNT,type=ACCELERATOR_TYPE \
  --traffic-split=0=100

Sostituisci quanto segue:

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.
• DEPLOYED_MODEL_NAME: un nome per DeployedModel. Puoi utilizzare anche il nome visualizzato di Model per DeployedModel.
• MACHINE_TYPE: facoltativo. Le risorse della macchina utilizzate per ogni nodo di questo deployment. La sua impostazione predefinita è n1-standard-2. Scopri di più sui tipi di macchina.
• MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base alle esigenze del carico della previsione, fino al numero massimo di nodi e mai inferiore a questo numero di nodi.
• MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base alle esigenze del carico della previsione, fino a questo numero di nodi e mai inferiore al numero minimo di nodi.
• ACCELERATOR_TYPE: gestisci la configurazione dell'acceleratore per la pubblicazione con GPU. Quando esegui il deployment di un modello con tipi di macchine Compute Engine, è possibile selezionare anche un acceleratore GPU e specificare il tipo. Le scelte sono "nvidia-tesla-a100", "nvidia-tesla-k80", "nvidia-tesla-p100", 'nvidia-tesla-p4', "nvidia-tesla-t4", "nvidia-tesla-v100".
• ACCELERATOR_COUNT: il numero di acceleratori da collegare a ogni macchina che esegue il job. In genere è 1. Se non specificato, il valore predefinito è 1.

Lo strumento Google Cloud CLI potrebbe richiedere alcuni secondi per eseguire il deployment del modello nell'endpoint. Una volta eseguito il deployment del modello, questo comando stampa il seguente output:

  Deployed a model to the endpoint xxxxx. Id of the deployed model: xxxxx.

Generare previsioni online dal modello di cui è stato eseguito il deployment

Per richiamare il modello tramite l'endpoint di Vertex AI Prediction, formatta la richiesta di previsione utilizzando un oggetto JSON Inference Request standard o un oggetto JSON Inference Request con un'estensione binaria e invia una richiesta all'endpoint rawPredict REST di Vertex AI Prediction.

Nota: invece dell'API predict, devi usare l'API rawPredict, perché i formati delle richieste di inferenza utilizzati da Triton non sono compatibili con il formato di input standard di Vertex AI Prediction.

L'esempio seguente utilizza il comando gcloud ai endpoints raw-predict:

ENDPOINT_ID=$(gcloud ai endpoints list \
   --region=LOCATION \
   --filter=display_name=ENDPOINT_NAME \
   --format="value(name)")

gcloud ai endpoints raw-predict $ENDPOINT_ID \
  --region=LOCATION \
  --http-headers=Content-Type=application/json \
  --request @instances.json

Sostituisci quanto segue:

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.

L'endpoint restituisce la seguente risposta per una richiesta valida:

{
    "id": "0",
    "model_name": "object_detector",
    "model_version": "1",
    "outputs": [{
        "name": "detection_anchor_indices",
        "datatype": "FP32",
        "shape": [1, 300],
        "data": [2.0, 1.0, 0.0, 3.0, 26.0, 11.0, 6.0, 92.0, 76.0, 17.0, 58.0, ...]
    }]
}

Eseguire la pulizia

Per evitare ulteriori addebiti di Vertex AI e di Artifact Registry, elimina le risorse Google Cloud che hai creato durante questo tutorial:

1. Per annullare il deployment del modello dall'endpoint ed eliminare l'endpoint, esegui questo comando nella shell:

   ENDPOINT_ID=$(gcloud ai endpoints list \
      --region=LOCATION \
      --filter=display_name=ENDPOINT_NAME \
      --format="value(name)")
   
   DEPLOYED_MODEL_ID=$(gcloud ai endpoints describe $ENDPOINT_ID \
      --region=LOCATION \
      --format="value(deployedModels.id)")
   
   gcloud ai endpoints undeploy-model $ENDPOINT_ID \
     --region=LOCATION \
     --deployed-model-id=$DEPLOYED_MODEL_ID
   
   gcloud ai endpoints delete $ENDPOINT_ID \
      --region=LOCATION \
      --quiet
   

   Sostituisci LOCATION con la regione in cui hai creato il modello nella sezione precedente.

2. Per eliminare il modello, esegui questo comando nella shell:

   MODEL_ID=$(gcloud ai models list \
      --region=LOCATION \
      --filter=display_name=DEPLOYED_MODEL_NAME \
      --format="value(name)")
   
   gcloud ai models delete $MODEL_ID \
      --region=LOCATION \
      --quiet
   

   Sostituisci LOCATION con la regione in cui hai creato il modello nella sezione precedente.

3. Per eliminare il repository Artifact Registry e l'immagine container al suo interno, esegui questo comando nella shell:

   gcloud artifacts repositories delete getting-started-nvidia-triton \
     --location=LOCATION \
     --quiet
   

   Sostituisci LOCATION con la regione in cui hai creato il repository Artifact Registry in una sezione precedente.

Limitazioni

• Il container personalizzato Triton non è compatibile con Vertex Explainable AI o Vertex AI Model Monitoring.

Passaggi successivi

• Fai riferimento ai tutorial sui blocchi note Jupyter per Vertex AI per i pattern di deployment con il server di inferenza NVIDIA Triton su Vertex AI Prediction.