Pubblicazione di previsioni con NVIDIA Triton

Questa pagina descrive come gestire le richieste di previsione con il server di inferenza NVIDIA Triton utilizzando Vertex AI Prediction. NVIDIA Triton Inference Server (Triton) è una soluzione di servizio di inferenza open source di NVIDIA ottimizzata sia per CPU che per GPU e semplifica il processo di servizio di inferenza.

NVIDIA Triton su Vertex AI Prediction

Vertex AI Prediction supporta il deployment dei modelli sul server di inferenza Triton in esecuzione su un container personalizzato pubblicato da NVIDIA GPU Cloud (NGC) - immagine del server di inferenza NVIDIA Triton. Le immagini Triton di NVIDIA dispongono di tutti i pacchetti e le configurazioni richiesti che soddisfano i requisiti di Vertex AI per le immagini dei container di pubblicazione personalizzata. L'immagine contiene il server di inferenza Triton con il 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 di ML come XGBoost, LightGBM e Scikit-Learn.

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

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

  • Supporto di più framework di deep learning e machine learning: Triton supporta il deployment di più modelli e un mix di framework e formati di modelli: TensorFlow (SavedModel e GraphDef), PyTorch (TorchScript), TensorRT, ONNX, OpenVINO e backend FIL per supportare framework come XGBoost, LightGBM, Scikit-Learn e qualsiasi formato di modello personalizzato in Python o C++.
  • Esecuzione di più modelli contemporaneamente: Triton consente di eseguire contemporaneamente più modelli, più istanze dello stesso modello o entrambi sulla stessa risorsa di calcolo con zero o più GPU.
  • Ensembling di modelli (concatenazione o pipeline): Triton ensemble supporta casi d'uso in cui più modelli sono composti come pipeline (o un DAG, grafo diretto aciclico) con tensori di input e output collegati tra loro. Inoltre, con un backend Python di Triton, puoi includere qualsiasi logica di pre-elaborazione, post-elaborazione o controllo del flusso definita da Business Logic Scripting (BLS).
  • Esegui su backend CPU e GPU:Triton supporta l'inferenza per i modelli di cui è stato eseguito il deployment su nodi con CPU e GPU.
  • Aggregazione dinamica delle richieste di previsione: per i modelli che supportano l'aggregazione, Triton dispone di algoritmi di pianificazione e aggregazione integrati. Questi algoritmi combinano dinamicamente le singole richieste di inferenza in batch lato server per migliorare il throughput dell'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 NGC di NVIDIA. 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.

NVIDIA Triton Image 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 contenitore Triton in base alle esigenze

Per iniziare: pubblicazione di previsioni con NVIDIA Triton

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

triton-on-vertex-ai-prediction

  • Un modello ML da pubblicare 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 contenitore di pubblicazione personalizzato e alla relativa configurazione.
  • Il modello di Vertex AI Model Registry viene eseguito in un endpoint di previsione di Vertex AI su cui è in esecuzione il server di inferenza Triton come contenitore personalizzato su nodi di calcolo con CPU e GPU.
  • Le richieste di inferenza arrivano al server di inferenza Triton tramite un endpoint di previsione Vertex AI e vengono inoltrate allo scheduler appropriato.
  • Il backend esegue l'inferenza utilizzando gli input forniti nelle richieste agrupate e restituisce una risposta.
  • Triton fornisce endpoint di salute di idoneità e attività che consentono l'integrazione di Triton negli 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 genera previsioni online. Esegui il deployment di un contenitore su cui è in esecuzione Triton per fornire le previsioni di un modello di rilevamento di oggetti di TensorFlow Hub preaddestrato sul set di dati COCO 2017. Puoi quindi utilizzare la previsione di Vertex AI per rilevare gli oggetti in un'immagine.

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

Prima di iniziare

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API and Artifact Registry API APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API and Artifact Registry API APIs.

    Enable the APIs

    8.

  8. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Per tutto il tutorial, ti consigliamo di utilizzare Cloud Shell per interagire con Google Cloud. Se vuoi utilizzare una shell Bash diversa anziché Cloud Shell, esegui la seguente configurazione aggiuntiva:

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command: 

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

Crea ed esegui il push dell'immagine container

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

Scaricare gli artefatti del modello

Gli elementi del modello sono file creati dall'addestramento ML che puoi utilizzare per fornire le previsioni. Contengono, come minimo, la struttura e i pesi del tuo modello di ML addestrato. Il formato degli elementi del modello dipende dal framework ML utilizzato per l'addestramento.

Per questo tutorial, anziché addestrare un modello da zero, scarica il modello di rilevamento degli oggetti da TensorFlow Hub che è stato addestrato sul set di dati COCO 2017. Triton si aspetta che il repository dei modelli sia organizzato nella seguente struttura per il servizio nel 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 contenente 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. Nello specifico, i modelli TensorRT, TensorFlow SavedModel e ONNX non richiedono un file di configurazione del modello perché Triton può dedurre automaticamente tutte le impostazioni richieste. Per tutti gli altri tipi di modelli è necessario 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 localmente, il repository del modello sarà organizzato come segue:

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

Copia gli elementi del modello in un bucket Cloud Storage

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

gcloud storage cp ./models/object_detector MODEL_ARTIFACTS_REPOSITORY/ --recursive

Crea un repository Artifact Registry

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

Abilita il servizio dell'API Artifact Registry per il tuo progetto.

gcloud services enable artifactregistry.googleapis.com

Esegui il seguente comando nella shell per creare il repository Artifact Registry:

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

Sostituisci LOCATION_ID con la regione in cui Artifact Registry memorizza l'immagine container. In un secondo momento, dovrai creare una risorsa modello Vertex AI su un endpoint regionale corrispondente a questa regione, quindi scegli una regione in cui Vertex AI ha un endpoint regionale, come us-central1.

Al termine dell'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 sia in linea con i requisiti dei container personalizzati di Vertex AI per la pubblicazione. Puoi estrarre l'immagine utilizzando docker e contrassegna il percorso di Artifact Registry in 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_ID-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference

Sostituisci quanto segue:

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

L'esecuzione del comando potrebbe richiedere diversi minuti.

Prepara il file del payload per testare le richieste di previsione

Per inviare al server del contenitore una richiesta di previsione, prepara il payload con un file immagine di esempio che utilizza Python. Esegui lo script Python seguente per generare il file del 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

(Facoltativo) Esegui il contenitore localmente

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

  1. Per eseguire l'immagine container in locale, esegui il seguente comando nella shell:

    docker run -t -d -p 8000:8000 --rm \
  --name=local_object_detector \
  -e AIP_MODE=True \
  LOCATION_ID-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_ID: 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 Cloud Storage in cui si trovano gli elementi del modello.

    Questo comando esegue un container in modalità distinta, mappando la porta 8000 del container alla porta 8000 dell'ambiente locale. L'immagine Triton di NGC configura Triton in modo da utilizzare la porta 8000.

  2. Per inviare al server del contenitore un controllo di stato, esegui il seguente 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 200.

  3. Esegui il seguente comando per inviare al server del contenitore una richiesta di previsione utilizzando il payload generato in precedenza e per ricevere 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 di oggetti di 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 interrompere il contenitore, esegui il seguente comando nella shell:

    docker stop local_object_detector

Esegui il push dell'immagine del contenitore 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 in Artifact Registry nella regione scelta, esegui il seguente comando nella shell:

    gcloud auth configure-docker LOCATION_ID-docker.pkg.dev
    • Sostituisci LOCATION_ID con la regione in cui hai creato il repository in una sezione precedente.

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

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

    Sostituisci quanto segue, come hai fatto nella sezione precedente:

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

Esegui il deployment del modello

In questa sezione crei un modello e un endpoint, quindi esegui il deployment del modello nell'endpoint.

crea un modello

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

Prima di creare il modello, leggi la sezione Impostazioni per i contenitori personalizzati per sapere se devi specificare i campi facoltativi sharedMemorySizeMb, startupProbe e healthProbe per il contenitore. 

gcloud ai models upload \
    --region=LOCATION_ID \
    --display-name=DEPLOYED_MODEL_NAME \
    --container-image-uri=LOCATION_ID-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 il DeployedModel. Puoi utilizzare il nome visualizzato del Model anche per DeployedModel.

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

Creazione di un endpoint

Devi eseguire il deployment del modello in un endpoint prima di poterlo utilizzare per fornire predizioni online. Se stai eseguendo il deployment di un modello in un endpoint esistente, puoi saltare questo passaggio. Nell'esempio seguente viene utilizzato il comando gcloud ai endpoints create:

gcloud ai endpoints create \
    --region=LOCATION_ID \
    --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

Una volta che l'endpoint è pronto, esegui il deployment del modello. 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 endpoint che esegue Triton su GPU per accelerare il servizio di previsione e senza suddividere il traffico tra più risorse DeployedModel:

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

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

gcloud ai endpoints deploy-model $ENDPOINT_ID \
    --region=LOCATION_ID \
    --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 il DeployedModel. Puoi utilizzare il nome visualizzato del Model anche per DeployedModel.
  • MACHINE_TYPE: facoltativo. Le risorse della macchina utilizzate per ogni nodo di questo deployment. L'impostazione predefinita è n1-standard-2. Scopri di più sui tipi di macchine.
  • MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico della previsione, fino al numero massimo di nodi e mai meno di questo numero.
  • MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico della previsione, fino a questo numero di nodi e mai inferiore al numero minimo di nodi.

  • 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.

  • ACCELERATOR_TYPE: gestisci la configurazione dell'acceleratore per il servizio GPU. Quando esegui il deployment di un modello con i tipi di macchine Compute Engine, è possibile selezionare anche un acceleratore GPU e il tipo deve essere specificato. Le opzioni sono nvidia-tesla-a100, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-t4 e nvidia-tesla-v100.

Il deployment del modello nell'endpoint potrebbe richiedere alcuni secondi con Google Cloud CLI. Quando il modello viene implementato correttamente, questo comando stampa il seguente output:

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

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

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

Nell'esempio seguente viene utilizzato il comando gcloud ai endpoints raw-predict:

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

gcloud ai endpoints raw-predict $ENDPOINT_ID \
    --region=LOCATION_ID \
    --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, ...]
    }]
}

Esegui la pulizia

Per evitare ulteriori addebiti di Vertex AI e 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 il seguente comando nella shell:

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

DEPLOYED_MODEL_ID=$(gcloud ai endpoints describe $ENDPOINT_ID \
    --region=LOCATION_ID \
    --format="value(deployedModels.id)")

gcloud ai endpoints undeploy-model $ENDPOINT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=$DEPLOYED_MODEL_ID

gcloud ai endpoints delete $ENDPOINT_ID \
    --region=LOCATION_ID \
    --quiet

    Sostituisci LOCATION_ID con la regione in cui hai creato il modello in una sezione precedente.

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

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

gcloud ai models delete $MODEL_ID \
    --region=LOCATION_ID \
    --quiet

    Sostituisci LOCATION_ID con la regione in cui hai creato il modello in una sezione precedente.

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

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

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

Limitazioni

Passaggi successivi