Esegui il deployment di un sistema di inferenza TensorFlow scalabile

Last reviewed 2023-11-02 UTC

Questo documento descrive come eseguire il deployment dell'architettura di riferimento descritta in Sistema di inferenza TensorFlow scalabile.

Questa serie è rivolta agli sviluppatori che hanno familiarità con Google Kubernetes Engine e i framework di machine learning (ML), tra cui TensorFlow e NVIDIA TensorRT.

Dopo aver completato il deployment, consulta Misurare e ottimizzare le prestazioni di un sistema di inferenza TensorFlow.

Architettura

Il seguente diagramma mostra l'architettura del sistema di inferenza.

Architettura del sistema di inferenza.

Cloud Load Balancing invia il traffico delle richieste al cluster GKE più vicino. Il cluster contiene un pod per ogni nodo. In ogni pod, un Triton Inference Server fornisce un servizio di inferenza (per gestire i modelli ResNet-50) e una GPU NVIDIA T4 migliora le prestazioni. I server di monitoraggio sul cluster raccolgono dati delle metriche sull'utilizzo della GPU e della memoria.

Per maggiori dettagli, consulta Sistema di inferenza TensorFlow scalabile.

Obiettivi

Scaricare un modello ResNet-50 preaddestrato e utilizzare l'integrazione di TensorFlow con TensorRT (TF-TRT) per applicare le ottimizzazioni
Gestisci un modello ResNet-50 da un server di inferenza NVIDIA Triton
Crea un sistema di monitoraggio per Triton utilizzando Prometheus e Grafana
Crea uno strumento di test di carico utilizzando Locust

Costi

Oltre alla GPU NVIDIA T4, in questo deployment utilizzerai i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

Al termine del deployment, non eliminare le risorse che hai creato. Ti servono queste risorse durante la misurazione e l'ottimizzazione del deployment.

Prima di iniziare

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.

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

Vai al selettore progetti

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

Attiva l'API GKE.

Abilita l'API

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

Vai al selettore progetti

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

Attiva l'API GKE.

Abilita l'API

Crea modelli ottimizzati con TF-TRT

In questa sezione creerai un ambiente di lavoro e ottimizzerai il modello preaddestrato.

Il modello preaddestrato utilizza il set di dati falso all'indirizzo gs://cloud-tpu-test-datasets/fake_imagenet/. È inoltre disponibile una copia del modello preaddestrato nella località di Cloud Storage all'indirizzo gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/.

Crea un ambiente di lavoro

Per il tuo ambiente di lavoro, puoi creare un'istanza Compute Engine utilizzando Deep Learning VM Image. Ottimizzi e quantizzi il modello ResNet-50 con TensorRT su questa istanza.

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell

Esegui il deployment di un'istanza denominata working-vm:

gcloud config set project PROJECT_ID
gcloud config set compute/zone us-west1-b
gcloud compute instances create working-vm \
    --scopes cloud-platform \
    --image-family common-cu113 \
    --image-project deeplearning-platform-release \
    --machine-type n1-standard-8 \
    --min-cpu-platform="Intel Skylake" \
    --accelerator=type=nvidia-tesla-t4,count=1 \
    --boot-disk-size=200GB \
    --maintenance-policy=TERMINATE \
    --metadata="install-nvidia-driver=True"

Sostituisci PROJECT_ID con l'ID del progetto Google Cloud che hai creato in precedenza.

Questo comando avvia un'istanza Compute Engine utilizzando NVIDIA T4. Al primo avvio, installa automaticamente il driver GPU NVIDIA compatibile con TensorRT 5.1.5.

Creare file di modello con ottimizzazioni diverse

In questa sezione applicherai le seguenti ottimizzazioni al modello ResNet-50 originale utilizzando TF-TRT:

Ottimizzazione del grafico
Conversione a FP16 con l'ottimizzazione del grafico
Quantizzazione con INT8 con l'ottimizzazione del grafico

Per maggiori dettagli su queste ottimizzazioni, consulta Ottimizzazione delle prestazioni.

Nella console Google Cloud, vai a Compute Engine > Istanze VM.

Vai a Istanze VM

Vedrai l'istanza working-vm che hai creato in precedenza.
Per aprire la console del terminale dell'istanza, fai clic su SSH.

Utilizza questo terminale per eseguire il resto dei comandi in questo documento.

Nel terminale, clona il repository richiesto e cambia la directory attuale:

cd $HOME
git clone https://github.com/GoogleCloudPlatform/gke-tensorflow-inference-system-tutorial
cd gke-tensorflow-inference-system-tutorial/server

Scarica il modello ResNet-50 preaddestrato in una directory locale:

mkdir -p models/resnet/original/00001
gsutil cp -R gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/* models/resnet/original/00001

Crea un'immagine container che contenga gli strumenti di ottimizzazione per TF-TRT:
```
docker build ./ -t trt-optimizer
docker image list
```
L'ultimo comando mostra una tabella di repository.
Nella tabella, copia l'ID immagine nella riga relativa al repository tft-optimizer.

Applica le ottimizzazioni (ottimizzazione del grafico, conversione a FP16 e quantizzazione con INT8) al modello originale:

export IMAGE_ID=IMAGE_ID

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='FP32' \
    --batch-size=64

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='FP16' \
    --batch-size=64

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='INT8' \
    --batch-size=64 \
    --calib-image-dir='gs://cloud-tpu-test-datasets/fake_imagenet/' \
    --calibration-epochs=10

Sostituisci IMAGE_ID con l'ID immagine di tft-optimizer che hai copiato nel passaggio precedente.

L'opzione --calib-image-dir specifica la posizione dei dati di addestramento utilizzati per il modello preaddestrato. Gli stessi dati di addestramento vengono usati per la calibrazione per la quantizzazione di INT8. Il processo di calibrazione può richiedere circa 5 minuti.

Al termine dell'esecuzione dei comandi, l'ultima riga di output è simile alla seguente, in cui i modelli ottimizzati vengono salvati in ./models/resnet:

INFO:tensorflow:SavedModel written to: models/resnet/INT8/00001/saved_model.pb

La struttura delle directory è simile alla seguente:

models
└── resnet
    ├── FP16
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    ├── FP32
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    ├── INT8
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    └── original
        └── 00001
            ├── saved_model.pb
            └── variables
                ├── variables.data-00000-of-00001
                └── variables.index

La seguente tabella riassume la relazione tra le directory e le ottimizzazioni.

Directory	Ottimizzazione
`FP16`	Conversione a FP16 oltre all'ottimizzazione del grafico
`FP32`	Ottimizzazione del grafico
`INT8`	Quantizzazione con INT8 oltre all'ottimizzazione del grafico
`original`	Modello originale (nessuna ottimizzazione con TF-TRT)

Deployment di un server di inferenza

In questa sezione eseguirai il deployment dei server Triton con cinque modelli. Per prima cosa, carica in Cloud Storage il programma binario del modello che hai creato nella sezione precedente. Poi creerai un cluster GKE ed eseguirai il deployment dei server Triton sul cluster.

Carica il programma binario del modello

Nel terminale SSH, carica i file binari del modello e i file di configurazione config.pbtxt in un bucket di archiviazione:

export PROJECT_ID=PROJECT_ID
export BUCKET_NAME=${PROJECT_ID}-models

mkdir -p original/1/model/
cp -r models/resnet/original/00001/* original/1/model/
cp original/config.pbtxt original/1/model/
cp original/imagenet1k_labels.txt original/1/model/

mkdir -p tftrt_fp32/1/model/
cp -r models/resnet/FP32/00001/* tftrt_fp32/1/model/
cp tftrt_fp32/config.pbtxt tftrt_fp32/1/model/
cp tftrt_fp32/imagenet1k_labels.txt tftrt_fp32/1/model/

mkdir -p tftrt_fp16/1/model/
cp -r models/resnet/FP16/00001/* tftrt_fp16/1/model/
cp tftrt_fp16/config.pbtxt tftrt_fp16/1/model/
cp tftrt_fp16/imagenet1k_labels.txt tftrt_fp16/1/model/

mkdir -p tftrt_int8/1/model/
cp -r models/resnet/INT8/00001/* tftrt_int8/1/model/
cp tftrt_int8/config.pbtxt tftrt_int8/1/model/
cp tftrt_int8/imagenet1k_labels.txt tftrt_int8/1/model/

mkdir -p tftrt_int8_bs16_count4/1/model/
cp -r models/resnet/INT8/00001/* tftrt_int8_bs16_count4/1/model/
cp tftrt_int8_bs16_count4/config.pbtxt tftrt_int8_bs16_count4/1/model/
cp tftrt_int8_bs16_count4/imagenet1k_labels.txt tftrt_int8_bs16_count4/1/model/

gsutil mb gs://${BUCKET_NAME}
gsutil -m cp -R original tftrt_fp32 tftrt_fp16 tftrt_int8 tftrt_int8_bs16_count4 \
    gs://${BUCKET_NAME}/resnet/

Sostituisci PROJECT_ID con l'ID del progetto Google Cloud che hai creato in precedenza.

I seguenti parametri di ottimizzazione sono specificati nei file config.pbtxt:

Nome modello
Nome tensore di input e nome tensore di output
Allocazione di GPU per ciascun modello
Dimensione del batch e numero di gruppi di istanze

Ad esempio, il file original/1/model/config.pbtxt include i seguenti contenuti:

name: "original"
platform: "tensorflow_savedmodel"
max_batch_size: 64
input {
    name: "input"
    data_type: TYPE_FP32
    format: FORMAT_NHWC
    dims: [ 224, 224, 3 ]
}
output {
    name: "probabilities"
    data_type: TYPE_FP32
    dims: 1000
    label_filename: "imagenet1k_labels.txt"
}
default_model_filename: "model"
instance_group [
  {
    count: 1
    kind: KIND_GPU
  }
]
dynamic_batching {
  preferred_batch_size: [ 64 ]
  max_queue_delay_microseconds: 20000
}

Per maggiori dettagli sulle dimensioni del batch e sul numero di gruppi di istanze, consulta Ottimizzazione delle prestazioni.

La tabella seguente riassume i cinque modelli di cui hai eseguito il deployment in questa sezione.

Nome modello	Ottimizzazione
`original`	Modello originale (nessuna ottimizzazione con TF-TRT)
`tftrt_fp32`	Ottimizzazione del grafico (dimensione batch=64, gruppi di istanze=1)
`tftrt_fp16`	Conversione a FP16 in aggiunta all'ottimizzazione del grafico (dimensione batch=64, gruppi di istanze=1)
`tftrt_int8`	Quantizzazione con INT8 oltre all'ottimizzazione del grafico (dimensione batch=64, gruppi di istanze=1)
`tftrt_int8_bs16_count4`	Quantizzazione con INT8 oltre all'ottimizzazione del grafico (dimensione batch=16, gruppi di istanze=4)

Deployment di server di inferenza con Triton

Nel terminale SSH, installa e configura il pacchetto di autenticazione, che gestisce i cluster GKE:

export USE_GKE_GCLOUD_AUTH_PLUGIN=True
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin

Crea un cluster GKE e un pool di nodi GPU con nodi di computing che utilizzano una GPU NVIDIA T4:
```
gcloud auth login
gcloud config set compute/zone us-west1-b
gcloud container clusters create tensorrt-cluster \
    --num-nodes=20
gcloud container node-pools create t4-gpu-pool \
    --num-nodes=1 \
    --machine-type=n1-standard-8 \
    --cluster=tensorrt-cluster \
    --accelerator type=nvidia-tesla-t4,count=1
```
Il flag --num-nodes specifica 20 istanze per il cluster GKE e un'istanza per il pool di nodi GPU t4-gpu-pool.

Il pool di nodi GPU è composto da una singola istanza n1-standard-8 con una GPU NVIDIA T4. Il numero di istanze GPU deve essere uguale o superiore al numero di pod di server di inferenza, poiché la GPU NVIDIA T4 non può essere condivisa da più pod nella stessa istanza.

Mostra le informazioni sul cluster:

gcloud container clusters list

L'output è simile al seguente:

NAME              LOCATION    MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
tensorrt-cluster  us-west1-b  1.14.10-gke.17  XX.XX.XX.XX    n1-standard-1  1.14.10-gke.17  21         RUNNING

Mostra le informazioni sul pool di nodi:

gcloud container node-pools list --cluster tensorrt-cluster

L'output è simile al seguente:

NAME          MACHINE_TYPE   DISK_SIZE_GB  NODE_VERSION
default-pool  n1-standard-1  100           1.14.10-gke.17
t4-pool       n1-standard-8  100           1.14.10-gke.17

Abilita il carico di lavoro daemonSet:

gcloud container clusters get-credentials tensorrt-cluster
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Questo comando carica il driver GPU NVIDIA sui nodi nel pool di nodi GPU. Inoltre, carica automaticamente il driver quando aggiungi un nuovo nodo al pool di nodi GPU.

Esegui il deployment dei server di inferenza sul cluster:

sed -i.bak "s/YOUR-BUCKET-NAME/${PROJECT_ID}-models/" trtis_deploy.yaml
kubectl create -f trtis_service.yaml
kubectl create -f trtis_deploy.yaml

Attendi qualche minuto finché i servizi non diventano disponibili.

Ottieni l'indirizzo clusterIP di Triton e archivialo in una variabile di ambiente:

export TRITON_IP=$(kubectl get svc inference-server \
  -o "jsonpath={.spec['clusterIP']}")
echo ${TRITON_IP}

A questo punto, il server di inferenza fornisce i quattro modelli ResNet-50 che hai creato nella sezione Creare file di modello con ottimizzazioni diverse. I client possono specificare il modello da utilizzare durante l'invio delle richieste di inferenza.

Esegui il deployment dei server di monitoraggio con Prometheus e Grafana

Nel terminale SSH, esegui il deployment dei server Prometheus nel cluster:

sed -i.bak "s/CLUSTER-IP/${TRITON_IP}/" prometheus-configmap.yml
kubectl create namespace monitoring
kubectl apply -f prometheus-service.yml -n monitoring
kubectl create -f clusterRole.yml
kubectl create -f prometheus-configmap.yml -n monitoring
kubectl create -f prometheus-deployment.yml -n monitoring

Recupera l'URL endpoint del servizio Prometheus.
```
ip_port=$(kubectl get svc prometheus-service \
  -o "jsonpath={.spec['clusterIP']}:{.spec['ports'][0]['port']}" -n monitoring)
echo "http://${ip_port}"
```
Prendi nota dell'URL dell'endpoint di Prometheus, perché lo utilizzerai per configurare Grafana in un secondo momento.

Esegui il deployment di server Grafana sul cluster:

kubectl create -f grafana-service.yml -n monitoring
kubectl create -f grafana-deployment.yml -n monitoring

Attendi qualche minuto finché tutti i servizi non diventano disponibili.

Recupera l'URL dell'endpoint del servizio Grafana.

ip_port=$(kubectl get svc grafana-service \
  -o "jsonpath={.status['loadBalancer']['ingress'][0]['ip']}:{.spec['ports'][0]['port']}" -n monitoring)
echo "http://${ip_port}"

Annota l'URL dell'endpoint di Grafana da utilizzare nel passaggio successivo.

Da un browser web, vai all'URL di Grafana annotato nel passaggio precedente.
Accedi con l'ID utente e la password predefiniti (admin e admin). Quando richiesto, modifica la password predefinita.
Fai clic su Aggiungi la tua prima origine dati e seleziona Prometheus nell'elenco Database delle serie temporali.
Nella scheda Impostazioni, nel campo URL, inserisci l'URL dell'endpoint di Prometheus che hai annotato in precedenza.
Fai clic su Salva e testa, quindi torna alla schermata Home.
Aggiungi una metrica di monitoraggio per nv_gpu_utilization:
1. Fai clic su Crea la tua prima dashboard e poi su Aggiungi visualizzazione.
2. Nell'elenco Origine dati, seleziona Prometheus.
3. Nella scheda Query, nel campo Metrica inserisci nv_gpu_utilization.
4. Nella sezione Opzioni riquadro, nel campo Titolo, inserisci GPU Utilization e poi fai clic su Applica.
  
  La pagina mostra un riquadro per l'utilizzo della GPU.
Aggiungi una metrica di monitoraggio per nv_gpu_memory_used_bytes:
1. Fai clic su Aggiungi e seleziona Visualizzazione.
2. Nella scheda Query, nel campo Metrica inserisci nv_gpu_memory_used_bytes.
3. Nella sezione Opzioni riquadro, inserisci GPU Memory Used nel campo Titolo e fai clic su Salva.
Per aggiungere la dashboard, fai clic su Salva nel riquadro Salva dashboard.

Vedrai i grafici relativi all'utilizzo della GPU e alla memoria GPU utilizzata.

Esegui il deployment di uno strumento di test di carico

In questa sezione eseguirai il deployment dello strumento di test di carico Locust su GKE e genererai un carico di lavoro per misurare le prestazioni dei server di inferenza.

Nel terminale SSH, crea un'immagine Docker contenente le librerie client Triton e caricala in Container Registry:

cd ../client
git clone https://github.com/triton-inference-server/server
cd server
git checkout r19.05
sed -i.bak "s/bootstrap.pypa.io\/get-pip.py/bootstrap.pypa.io\/pip\/2.7\/get-pip.py/" Dockerfile.client
docker build -t tritonserver_client -f Dockerfile.client .
gcloud auth configure-docker
docker tag tritonserver_client \
    gcr.io/${PROJECT_ID}/tritonserver_client
docker push gcr.io/${PROJECT_ID}/tritonserver_client

Il processo di compilazione può richiedere circa 5 minuti. Al termine della procedura viene visualizzato un prompt dei comandi nel terminale SSH.

Al termine del processo di compilazione, crea un'immagine Docker per generare il carico di lavoro di test e caricala in Container Registry:
```
cd ..
sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" Dockerfile
docker build -t locust_tester -f Dockerfile .
docker tag locust_tester gcr.io/${PROJECT_ID}/locust_tester
docker push gcr.io/${PROJECT_ID}/locust_tester
```
Non modificare o sostituire YOUR-PROJECT-ID nei comandi.

Questa immagine viene creata a partire dall'immagine creata nel passaggio precedente.

Esegui il deployment dei file Locust service_master.yaml e deployment_master.yaml:

sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_master.yaml
sed -i.bak "s/CLUSTER-IP-TRTIS/${TRITON_IP}/" deployment_master.yaml

kubectl create namespace locust
kubectl create configmap locust-config --from-literal model=original --from-literal saddr=${TRITON_IP} --from-literal rps=10 -n locust

kubectl apply -f service_master.yaml -n locust
kubectl apply -f deployment_master.yaml -n locust

La risorsa configmap viene utilizzata per specificare il modello di machine learning a cui i client inviano le richieste per l'inferenza.

Attendi qualche minuto finché i servizi non diventano disponibili.

Ottieni l'indirizzo clusterIP del client locust-master e memorizzalo in una variabile di ambiente:

export LOCUST_MASTER_IP=$(kubectl get svc locust-master -n locust \
    -o "jsonpath={.spec['clusterIP']}")
echo ${LOCUST_MASTER_IP}

Esegui il deployment del client Locust:
```
sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_slave.yaml
sed -i.bak "s/CLUSTER-IP-LOCUST-MASTER/${LOCUST_MASTER_IP}/" deployment_slave.yaml
kubectl apply -f deployment_slave.yaml -n locust
```
Questi comandi eseguono il deployment di 10 pod del client Locust che puoi utilizzare per generare carichi di lavoro di test. Se non riesci a generare un numero sufficiente di richieste con il numero attuale di client, puoi modificare il numero di pod utilizzando il comando seguente:
```
kubectl scale deployment/locust-slave --replicas=20 -n locust
```
Quando la capacità di un cluster predefinito non è sufficiente per aumentare il numero di repliche, ti consigliamo di aumentare il numero di nodi nel cluster GKE.
Copia l'URL della console Locust, quindi apri questo URL in un browser web:
```
export LOCUST_IP=$(kubectl get svc locust-master -n locust \
     -o "jsonpath={.status.loadBalancer.ingress[0].ip}")
echo "http://${LOCUST_IP}:8089"
```
Si apre la console Locust, dalla quale puoi generare carichi di lavoro di test.

Controlla i pod in esecuzione

Per assicurarti che il deployment dei componenti sia stato eseguito correttamente, controlla che i pod siano in esecuzione.

Nel terminale SSH, controlla il pod del server di inferenza:
```
kubectl get pods
```
L'output è simile al seguente:
```
NAME                                READY   STATUS    RESTARTS   AGE
inference-server-67786cddb4-qrw6r   1/1     Running   0          83m
```
Se non ottieni l'output previsto, assicurati di aver completato i passaggi descritti in Eseguire il deployment dei server di inferenza mediante Triton.

Controlla i pod di locuste:

kubectl get pods -n locust

L'output è simile al seguente:

NAME                                READY   STATUS    RESTARTS   AGE
locust-master-75f6f6d4bc-ttllr      1/1     Running   0          10m
locust-slave-76ddb664d9-8275p       1/1     Running   0          2m36s
locust-slave-76ddb664d9-f45ww       1/1     Running   0          2m36s
locust-slave-76ddb664d9-q95z9       1/1     Running   0          2m36s

Se non ottieni l'output previsto, assicurati di aver completato i passaggi descritti in Eseguire il deployment di uno strumento di test di carico.

Controlla i pod di monitoraggio:

kubectl get pods -n monitoring

L'output è simile al seguente:

NAME                                     READY   STATUS    RESTARTS   AGE
grafana-deployment-644bbcb84-k6t7v       1/1     Running   0          79m
prometheus-deployment-544b9b9f98-hl7q8   1/1     Running   0          81m

Se non ottieni l'output previsto, assicurati di aver completato i passaggi descritti in Eseguire il deployment dei server di monitoraggio con Prometheus e Grafana.

Nella prossima parte di questa serie, utilizzerai questo sistema di server di inferenza per scoprire in che modo le varie ottimizzazioni migliorano le prestazioni e come interpretarle. Per i passaggi successivi, consulta Misurare e ottimizzare le prestazioni di un sistema di inferenza TensorFlow.

Passaggi successivi

Scopri di più su Google Kubernetes Engine (GKE).
Scopri di più su Cloud Load Balancing.
Per ulteriori architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.