Esecuzione di carichi di lavoro di inferenza TensorFlow con TensorRT5 e GPU NVIDIA T4

---

Questo tutorial spiega come eseguire inferenze di deep learning su carichi di lavoro su larga scala utilizzando GPU NVIDIA TensorRT5 in esecuzione su Compute Engine.

Prima di iniziare, ecco alcuni elementi essenziali:

• L'inferenza del deep learning è la fase del processo di machine learning in cui viene utilizzato un modello addestrato per riconoscere, elaborare e classificare i risultati.
• NVIDIA TensorRT è una piattaforma ottimizzata per l'esecuzione di carichi di lavoro di deep learning.
• Le GPU vengono utilizzate per accelerare i carichi di lavoro che richiedono un'elaborazione intensiva di dati, come il machine learning e l'elaborazione di dati. Su Compute Engine sono disponibili diverse GPU NVIDIA. Questo tutorial utilizza GPU T4, poiché sono progettate specificamente per i carichi di lavoro di inferenza del deep learning.

Obiettivi

Questo tutorial illustra le seguenti procedure:

• Preparazione di un modello utilizzando un grafo preaddestrato.
• Test della velocità di inferenza di un modello con diverse modalità di ottimizzazione.
• Conversione di un modello personalizzato in TensorRT.
• Configurazione di un cluster multi-zonale. Questo cluster multizona è configurato come segue:
  • Creato su Deep Learning VM Image. Queste immagini sono preinstallate con TensorFlow, TensorFlow serving e TensorRT5.
  • Scalabilità automatica abilitata. La scalabilità automatica in questo tutorial si basa sull'utilizzo della GPU.
  • Bilanciamento del carico abilitato.
  • Firewall abilitato.
• Eseguire un carico di lavoro di inferenza nel cluster multi-zonale.

Costi

Il costo dell'esecuzione di questo tutorial varia in base alla sezione.

Puoi calcolare il costo utilizzando il Calcolatore prezzi.

Per stimare il costo per preparare il modello e testare le velocità di inferenza a diverse velocità di ottimizzazione, utilizza le seguenti specifiche:

• 1 istanza VM: n1-standard-8 (vCPU: 8, RAM 30 GB)
• 1 GPU NVIDIA T4

Per stimare il costo di configurazione del cluster multizona, utilizza le seguenti specifiche:

• 2 istanze VM: n1-standard-16 (vCPU: 16, RAM 60 GB)
• 4 GPU NVIDIA T4 per ogni istanza VM
• Un'unità SSD da 100 GB per ogni istanza VM
• 1 regola di inoltro

Prima di iniziare

Configurazione del progetto

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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. Enable the Compute Engine and Cloud Machine Learning APIs.

   Enable the APIs

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

7. Enable the Compute Engine and Cloud Machine Learning APIs.

   Enable the APIs

Configurazione degli strumenti

Per utilizzare Google Cloud CLI in questo tutorial:

1. Installa o esegui l'aggiornamento alla versione più recente di Google Cloud CLI.
2. (Facoltativo) Imposta una regione e una zona predefinite.

Preparazione del modello

Questa sezione illustra la creazione di un'istanza di una macchina virtuale (VM) utilizzata per eseguire il modello. Questa sezione spiega anche come scaricare un modello dal catalogo ufficiale dei modelli di TensorFlow.

1. Crea l'istanza VM. Questo tutorial è stato creato utilizzando tf-ent-2-10-cu113. Per le versioni più recenti delle immagini, consulta Scegliere un sistema operativo nella documentazione delle immagini VM per il deep learning.

   export IMAGE_FAMILY="tf-ent-2-10-cu113"
   export ZONE="us-central1-b"
   export INSTANCE_NAME="model-prep"
   gcloud compute instances create $INSTANCE_NAME \
      --zone=$ZONE \
      --image-family=$IMAGE_FAMILY \
      --machine-type=n1-standard-8 \
      --image-project=deeplearning-platform-release \
      --maintenance-policy=TERMINATE \
      --accelerator="type=nvidia-tesla-t4,count=1" \
      --metadata="install-nvidia-driver=True"
   

   Nota: puoi creare questa istanza in qualsiasi zona disponibile che supporta le GPU T4. È sufficiente una singola GPU per confrontare le diverse modalità di ottimizzazione di TensorRT.

2. Seleziona un modello. Questo tutorial utilizza il modello ResNet. Questo modello ResNet viene addestrato sul set di dati ImageNet in TensorFlow.

   Per scaricare il modello ResNet nell'istanza VM, esegui il comando seguente:

   wget -q http://download.tensorflow.org/models/official/resnetv2_imagenet_frozen_graph.pb

   Salva la posizione del modello ResNet nella variabile $WORKDIR. Sostituisci MODEL_LOCATION con la directory di lavoro che contiene il modello scaricato.

   export WORKDIR=MODEL_LOCATION

Eseguire il test di velocità di inferenza

Questa sezione illustra le seguenti procedure:

• Configurazione del modello ResNet.
• Eseguire test di inferenza in diverse modalità di ottimizzazione.
• Esamina i risultati dei test di inferenza.

Panoramica della procedura di test

TensorRT può migliorare la velocità di esecuzione dei carichi di lavoro di inferenza, ma il miglioramento più significativo proviene dal processo di quantizzazione.

La quantizzazione del modello è il processo mediante il quale riduci la precisione dei pesi di un modello. Ad esempio, se il peso iniziale di un modello è FP32, puoi ridurre la precisione a FP16, INT8 o addirittura INT4. È importante scegliere il giusto compromesso tra velocità (precisione dei pesi) e accuratezza di un modello. Fortunatamente, TensorFlow include funzionalità che fanno esattamente questo, misurando la precisione rispetto alla velocità o altre metriche come throughput, latenza, tassi di conversione dei nodi e tempo di addestramento totale.

Nota: al momento questo test è limitato ai modelli di riconoscimento delle immagini, tuttavia non dovrebbe essere troppo difficile implementare un test personalizzato basato su questo codice.

Procedura

1. Configura il modello ResNet. Per configurare il modello, esegui i seguenti comandi:

   git clone https://github.com/tensorflow/models.git
   cd models
   git checkout f0e10716160cd048618ccdd4b6e18336223a172f
   touch research/__init__.py
   touch research/tensorrt/__init__.py
   cp research/tensorrt/labellist.json .
   cp research/tensorrt/image.jpg ..
   

2. Esegui il test. Il completamento di questo comando richiede del tempo.

   python -m research.tensorrt.tensorrt \
      --frozen_graph=$WORKDIR/resnetv2_imagenet_frozen_graph.pb \
      --image_file=$WORKDIR/image.jpg \
      --native --fp32 --fp16 --int8 \
      --output_dir=$WORKDIR
   

   Dove:

   • $WORKDIR è la directory in cui hai scaricato il modello ResNet.
   • Gli argomenti --native sono le diverse modalità di quantizzazione da testare.

3. Esamina i risultati. Al termine del test, puoi confrontare i risultati dell'inferenza per ogni modalità di ottimizzazione.

   Predictions:
   Precision:  native [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty',     u'lakeside, lakeshore', u'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus']
   Precision:  FP32 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'lakeside,   lakeshore', u'sandbar, sand bar']
   Precision:  FP16 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'lakeside,   lakeshore', u'sandbar, sand bar']
   Precision:  INT8 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'grey         whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus', u'lakeside, lakeshore']
   

   Per visualizzare i risultati completi, esegui il seguente comando:

   cat $WORKDIR/log.txt

   

   Dai risultati, puoi vedere che FP32 e FP16 sono identici. Ciò significa che se hai dimestichezza con TensorRT, puoi iniziare subito a utilizzare FP16. INT8, mostra risultati leggermente peggiori.

   Inoltre, puoi vedere che l'esecuzione del modello con TensorRT5 mostra i seguenti risultati:

   • L'ottimizzazione FP32 migliora la velocità in uscita del 40%, passando da 314 fps a 440 fps. Allo stesso tempo, la latenza diminuisce di circa il 30%, passando a 0,28 ms anziché 0,40 ms.
   • L'utilizzo dell'ottimizzazione FP16, anziché del grafo TensorFlow nativo, aumenta la velocità del 214%, da 314 a 988 fps. Allo stesso tempo, la latenza si riduce di 0,12 ms, quasi tre volte in meno.
   • Con INT8, puoi osservare un aumento della velocità del 385% da 314 fps a 1524 fps con una latenza ridotta a 0,08 ms.

Conversione di un modello personalizzato in TensorRT

Per questa conversione, puoi utilizzare un modello INT8.

1. Scarica il modello. Per convertire un modello personalizzato in un grafico TensorRT, è necessario un modello salvato. Per ottenere un modello ResNet INT8 salvato, esegui il seguente comando:

   wget http://download.tensorflow.org/models/official/20181001_resnet/savedmodels/resnet_v2_fp32_savedmodel_NCHW.tar.gz
   tar -xzvf resnet_v2_fp32_savedmodel_NCHW.tar.gz

2. Converti il modello nel grafo TensorRT utilizzando TFTools. Per convertire il modello utilizzando TFTools, esegui il seguente comando:

   git clone https://github.com/GoogleCloudPlatform/ml-on-gcp.git
   cd ml-on-gcp/dlvm/tools
   python ./convert_to_rt.py \
      --input_model_dir=$WORKDIR/resnet_v2_fp32_savedmodel_NCHW/1538687196 \
      --output_model_dir=$WORKDIR/resnet_v2_int8_NCHW/00001 \
      --batch_size=128 \
      --precision_mode="INT8"
   

   Ora hai un modello INT8 nella directory $WORKDIR/resnet_v2_int8_NCHW/00001.

   Per assicurarti che tutto sia configurato correttamente, prova a eseguire un test di inferenza.

   tensorflow_model_server --model_base_path=$WORKDIR/resnet_v2_int8_NCHW/ --rest_api_port=8888

3. Carica il modello su Cloud Storage. Questo passaggio è necessario per poter utilizzare il modello dal cluster multi-zonale configurato nella sezione successiva. Per caricare il modello:

   1. Archivia il modello.

      tar -zcvf model.tar.gz ./resnet_v2_int8_NCHW/

   2. Carica l'archivio. Sostituisci GCS_PATH con il percorso del tuo bucket Cloud Storage.

      export GCS_PATH=GCS_PATH
      gcloud storage cp model.tar.gz $GCS_PATH
      

      Se necessario, puoi ottenere un grafo INT8 congelato da Cloud Storage all'URL:

      gs://cloud-samples-data/dlvm/t4/model.tar.gz

Configurazione di un cluster con più zone

Crea il cluster

Ora che hai un modello sulla piattaforma Cloud Storage, puoi creare un cluster.

1. Creare un modello di istanza. Un modello di istanza è una risorsa utile per creare nuove istanze. Consulta Modelli di istanza. Sostituisci YOUR_PROJECT_NAME con l'ID del tuo progetto.

   export INSTANCE_TEMPLATE_NAME="tf-inference-template"
   export IMAGE_FAMILY="tf-ent-2-10-cu113"
   export PROJECT_NAME=YOUR_PROJECT_NAME
   
   gcloud beta compute --project=$PROJECT_NAME instance-templates create $INSTANCE_TEMPLATE_NAME \
        --machine-type=n1-standard-16 \
        --maintenance-policy=TERMINATE \
        --accelerator=type=nvidia-tesla-t4,count=4 \
        --min-cpu-platform=Intel\ Skylake \
        --tags=http-server,https-server \
        --image-family=$IMAGE_FAMILY \
        --image-project=deeplearning-platform-release \
        --boot-disk-size=100GB \
        --boot-disk-type=pd-ssd \
        --boot-disk-device-name=$INSTANCE_TEMPLATE_NAME \
        --metadata startup-script-url=gs://cloud-samples-data/dlvm/t4/start_agent_and_inf_server_4.sh
   

   • Questo modello di istanza include uno script di avvio specificato dal parametro metadata.
     • Esegui questo script di avvio durante la creazione di ogni istanza che utilizza questo modello.
     • Questo script di avvio esegue i seguenti passaggi:
       • Installa un agente di monitoraggio che controlla l'utilizzo della GPU sull'istanza.
       • Scarica il modello.
       • Avvia il servizio di inferenza.
     • Nello script di avvio, tf_serve.py contiene la logica di inferenza. Questo esempio include un file Python molto piccolo basato sul pacchetto TFServe.
     • Per visualizzare lo script di avvio, consulta startup_inf_script.sh.

2. Crea un gruppo di istanze gestite (MIG). Questo gruppo di istanze gestite è necessario per configurare più istanze in esecuzione in zone specifiche. Le istanze vengono create in base al modello di istanza generato nel passaggio precedente.

   export INSTANCE_GROUP_NAME="deeplearning-instance-group"
   export INSTANCE_TEMPLATE_NAME="tf-inference-template"
   gcloud compute instance-groups managed create $INSTANCE_GROUP_NAME \
      --template $INSTANCE_TEMPLATE_NAME \
      --base-instance-name deeplearning-instances \
      --size 2 \
      --zones us-central1-a,us-central1-b
   

   Nota: INSTANCE_TEMPLATE_NAME è il nome del modello di istanza creato nel passaggio precedente.

   • Puoi creare questa istanza in qualsiasi zona disponibile che supporta le GPU T4. Assicurati di disporre di quote GPU disponibili nella zona.

     Nota: Le regioni Messico, Montréal e Osaka hanno tre zone in uno o due data center fisici. Queste regioni sono in fase di espansione per arrivare ad almeno tre data center fisici. Per ulteriori informazioni, consulta Località cloud e SLA della piattaforma Google Cloud. Per migliorare l'affidabilità dei carichi di lavoro, valuta la possibilità di eseguire un deployment multiregionale.

   • La creazione dell'istanza richiede del tempo. Puoi monitorare l'avanzamento eseguendo i seguenti comandi:

     export INSTANCE_GROUP_NAME="deeplearning-instance-group"

     gcloud compute instance-groups managed list-instances $INSTANCE_GROUP_NAME --region us-central1

     

   • Quando il gruppo di istanze gestite viene creato, dovresti visualizzare un output simile al seguente:

     

3. Verifica che le metriche siano disponibili nella pagina Cloud Monitoring di Google Cloud.

   1. Nella console Google Cloud, vai alla pagina Monitoring.

      Vai a Monitoring

   2. Se Metrics Explorer è visualizzato nel riquadro di navigazione, fai clic su Metrics Explorer. In caso contrario, seleziona Risorse e poi Esplora metriche.

   3. Cerca gpu_utilization.

      

   4. Se i dati arrivano, dovresti vedere qualcosa di simile a questo:

      

Abilita scalabilità automatica

1. Attiva la scalabilità automatica per il gruppo di istanze gestite.

   export INSTANCE_GROUP_NAME="deeplearning-instance-group"
   
   gcloud compute instance-groups managed set-autoscaling $INSTANCE_GROUP_NAME \
      --custom-metric-utilization metric=custom.googleapis.com/gpu_utilization,utilization-target-type=GAUGE,utilization-target=85 \
      --max-num-replicas 4 \
      --cool-down-period 360 \
      --region us-central1
   

   custom.googleapis.com/gpu_utilization è il percorso completo della metrica. Il campione specifica il livello 85, il che significa che ogni volta che l'utilizzo della GPU raggiunge l'85, la piattaforma crea una nuova istanza nel nostro gruppo.

2. Testa la scalabilità automatica. Per testare la scalabilità automatica, devi eseguire i seguenti passaggi:

   1. Accedi all'istanza tramite SSH. Consulta la sezione Connessione alle istanze.

   2. Utilizza lo strumento gpu-burn per caricare la GPU al 100% di utilizzo per 600 secondi:

      git clone https://github.com/GoogleCloudPlatform/ml-on-gcp.git
      cd ml-on-gcp/third_party/gpu-burn
      git checkout c0b072aa09c360c17a065368294159a6cef59ddf
      make
      ./gpu_burn 600 > /dev/null &
      

   3. Visualizza la pagina Cloud Monitoring. Osserva la scalabilità automatica. Il cluster viene scalato aggiungendo un'altra istanza.

      

   4. Nella console Google Cloud, vai alla pagina Gruppi di istanze.

      Vai a Gruppi di istanze

   5. Fai clic sul gruppo di istanze gestite deeplearning-instance-group.

   6. Fai clic sulla scheda Monitoraggio.

      A questo punto, la logica di scalabilità automatica dovrebbe provare a avviare il maggior numero possibile di istanze per ridurre il carico, senza alcun risultato:

      

      A questo punto puoi interrompere l'utilizzo delle istanze e osservare il ridimensionamento del sistema.

Configura un bilanciatore del carico

Ripercorriamo cosa hai fatto finora:

• Un modello addestrato, ottimizzato con TensorRT5 (INT8)
• Un gruppo di istanze gestite. Queste istanze hanno la scalabilità automatica abilitata in base all'utilizzo della GPU.

Ora puoi creare un bilanciatore del carico davanti alle istanze.

1. Creare controlli di integrità. I controlli di integrità vengono utilizzati per determinare se un determinato host sul nostro backend può gestire il traffico.

   export HEALTH_CHECK_NAME="http-basic-check"
   
   gcloud compute health-checks create http $HEALTH_CHECK_NAME \
      --request-path /v1/models/default \
      --port 8888
   

2. Crea un servizio di backend che includa un gruppo di istanze e un controllo di integrità.

   1. Crea il controllo di integrità.

      export HEALTH_CHECK_NAME="http-basic-check"
      export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
      
      gcloud compute backend-services create $WEB_BACKED_SERVICE_NAME \
         --protocol HTTP \
         --health-checks $HEALTH_CHECK_NAME \
         --global
      

   2. Aggiungi il gruppo di istanze al nuovo servizio di backend.

      export INSTANCE_GROUP_NAME="deeplearning-instance-group"
      export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
      
      gcloud compute backend-services add-backend $WEB_BACKED_SERVICE_NAME \
         --balancing-mode UTILIZATION \
         --max-utilization 0.8 \
         --capacity-scaler 1 \
         --instance-group $INSTANCE_GROUP_NAME \
         --instance-group-region us-central1 \
         --global
      

3. Configura l'URL di inoltro. Il bilanciatore del carico deve sapere quale URL può essere inoltrato ai servizi di backend.

   export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
   export WEB_MAP_NAME="map-all"
   
   gcloud compute url-maps create $WEB_MAP_NAME \
      --default-service $WEB_BACKED_SERVICE_NAME
   

4. Crea il bilanciatore del carico.

   export WEB_MAP_NAME="map-all"
   export LB_NAME="tf-lb"
   
   gcloud compute target-http-proxies create $LB_NAME \
      --url-map $WEB_MAP_NAME
   

5. Aggiungi un indirizzo IP esterno al bilanciatore del carico.

   export IP4_NAME="lb-ip4"
   
   gcloud compute addresses create $IP4_NAME \
      --ip-version=IPV4 \
      --network-tier=PREMIUM \
      --global
   

6. Trova l'indirizzo IP allocato.

   gcloud compute addresses list

7. Configura la regola di forwarding che indica a Google Cloud di inoltrare tutte le richieste dall'indirizzo IP pubblico al bilanciatore del carico.

   export IP=$(gcloud compute addresses list | grep ${IP4_NAME} | awk '{print $2}')
   export LB_NAME="tf-lb"
   export FORWARDING_RULE="lb-fwd-rule"
   
   gcloud compute forwarding-rules create $FORWARDING_RULE \
      --address $IP \
      --global \
      --load-balancing-scheme=EXTERNAL \
      --network-tier=PREMIUM \
      --target-http-proxy $LB_NAME \
      --ports 80
   

   Dopo la creazione delle regole di inoltro globale, possono trascorrere alcuni minuti prima che la configurazione venga propagata.

Attiva il firewall

1. Controlla se sono presenti regole firewall che consentono le connessioni da origini esterne alle tue istanze VM.

   gcloud compute firewall-rules list

2. Se non disponi di regole firewall per consentire queste connessioni, devi crearle. Per creare regole firewall, esegui i seguenti comandi:

   gcloud compute firewall-rules create www-firewall-80 \
      --target-tags http-server --allow tcp:80
   
   gcloud compute firewall-rules create www-firewall-8888 \
      --target-tags http-server --allow tcp:8888
   

Esecuzione di un'inferenza

1. Puoi utilizzare il seguente script Python per convertire le immagini in un formato che può essere caricato sul server.

   from PIL import Image
   import numpy as np
   import json
   import codecs
   
   
   img = Image.open("image.jpg").resize((240, 240))
   img_array=np.array(img)
   result = {
         "instances":[img_array.tolist()]
          }
   file_path="/tmp/out.json"
   print(json.dump(result, codecs.open(file_path, 'w', encoding='utf-8'), separators=(',', ':'), sort_keys=True, indent=4))
   

2. Esegui l'inferenza.

   curl -X POST $IP/v1/models/default:predict -d @/tmp/out.json

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

1. Elimina le regole di inoltro.

   gcloud compute forwarding-rules delete $FORWARDING_RULE --global

2. Elimina l'indirizzo IPv4.

   gcloud compute addresses delete $IP4_NAME --global

3. Elimina il bilanciatore del carico.

   gcloud compute target-http-proxies delete $LB_NAME

4. Elimina l'URL di inoltro.

   gcloud compute url-maps delete $WEB_MAP_NAME

5. Elimina il servizio di backend.

   gcloud compute backend-services delete $WEB_BACKED_SERVICE_NAME --global

6. Elimina i controlli di integrità.

   gcloud compute health-checks delete $HEALTH_CHECK_NAME

7. Elimina il gruppo di istanze gestite.

   gcloud compute instance-groups managed delete $INSTANCE_GROUP_NAME --region us-central1

8. Elimina il modello di istanza.

   gcloud beta compute --project=$PROJECT_NAME instance-templates delete $INSTANCE_TEMPLATE_NAME

9. Elimina le regole firewall.

   gcloud compute firewall-rules delete www-firewall-80

   gcloud compute firewall-rules delete www-firewall-8888