Triton Inference Server con Ultralytics YOLO11

Il Triton Inference Server (precedentemente noto come TensorRT Inference Server) è una soluzione software open source sviluppata da NVIDIA. Fornisce una soluzione di cloud inference ottimizzata per le GPU NVIDIA. Triton semplifica l'implementazione di modelli di IA su larga scala in produzione. L'integrazione di Ultralytics YOLO11 con Triton Inference Server consente di implementare carichi di lavoro di deep learning inference scalabili e ad alte prestazioni. Questa guida fornisce i passaggi per configurare e testare l'integrazione.

Guarda: Guida introduttiva a NVIDIA Triton Inference Server.

Cos'è Triton Inference Server?

Triton Inference Server è progettato per implementare una varietà di modelli di IA in produzione. Supporta una vasta gamma di framework di deep learning e machine learning, tra cui TensorFlow, PyTorch, ONNX Runtime e molti altri. I suoi principali casi d'uso sono:

Servire più modelli da una singola istanza del server
Caricamento e scaricamento dinamico del modello senza riavvio del server
Inferenza di ensemble, che consente di utilizzare più modelli insieme per ottenere risultati
Controllo delle versioni del modello per test A/B e aggiornamenti continui

Vantaggi principali di Triton Inference Server

L'utilizzo del server di inferenza Triton con Ultralytics YOLO11 offre diversi vantaggi:

Batching automatico: Raggruppa più richieste di AI prima di elaborarle, riducendo la latenza e migliorando la velocità di inferenza
Integrazione Kubernetes: Il design cloud-native funziona perfettamente con Kubernetes per la gestione e il ridimensionamento delle applicazioni AI
Ottimizzazioni specifiche per l'hardware: Sfrutta appieno le GPU NVIDIA per le massime prestazioni
Flessibilità del framework: Supporta più framework di intelligenza artificiale tra cui TensorFlow, PyTorch, ONNX e TensorRT
Open source e personalizzabile: Può essere modificato per adattarsi a esigenze specifiche, garantendo flessibilità per varie applicazioni di IA.

Prerequisiti

Assicurati di avere i seguenti prerequisiti prima di procedere:

Docker installato sulla tua macchina
Installa tritonclient:
```
pip install tritonclient[all]
```

Esportazione di YOLO11 in formato ONNX

Prima di distribuire il modello su Triton, è necessario esportarlo nel formato ONNX. ONNX (Open Neural Network Exchange) è un formato che consente di trasferire modelli tra diversi framework di deep learning. Utilizzare il export funzione dal YOLO classe:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model

# Retrieve metadata during export. Metadata needs to be added to config.pbtxt. See next section.
metadata = []


def export_cb(exporter):
    metadata.append(exporter.metadata)


model.add_callback("on_export_end", export_cb)

# Export the model
onnx_file = model.export(format="onnx", dynamic=True)

Configurazione del repository del modello Triton

Il repository di modelli Triton è una posizione di archiviazione in cui Triton può accedere e caricare i modelli.

Crea la struttura di directory necessaria:

from pathlib import Path

# Define paths
model_name = "yolo"
triton_repo_path = Path("tmp") / "triton_repo"
triton_model_path = triton_repo_path / model_name

# Create directories
(triton_model_path / "1").mkdir(parents=True, exist_ok=True)

Sposta il modello ONNX esportato nel repository Triton:

from pathlib import Path

# Move ONNX model to Triton Model path
Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")

# Create config file
(triton_model_path / "config.pbtxt").touch()

data = """
# Add metadata
parameters {
  key: "metadata"
  value {
    string_value: "%s"
  }
}

# (Optional) Enable TensorRT for GPU inference
# First run will be slow due to TensorRT engine conversion
optimization {
  execution_accelerators {
    gpu_execution_accelerator {
      name: "tensorrt"
      parameters {
        key: "precision_mode"
        value: "FP16"
      }
      parameters {
        key: "max_workspace_size_bytes"
        value: "3221225472"
      }
      parameters {
        key: "trt_engine_cache_enable"
        value: "1"
      }
      parameters {
        key: "trt_engine_cache_path"
        value: "/models/yolo/1"
      }
    }
  }
}
""" % metadata[0]  # noqa

with open(triton_model_path / "config.pbtxt", "w") as f:
    f.write(data)

Esecuzione del server di inferenza Triton

Esegui il server di inferenza Triton usando Docker:

import contextlib
import subprocess
import time

from tritonclient.http import InferenceServerClient

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:24.09-py3"  # 8.57 GB

# Pull the image
subprocess.call(f"docker pull {tag}", shell=True)

# Run the Triton server and capture the container ID
container_id = (
    subprocess.check_output(
        f"docker run -d --rm --runtime=nvidia --gpus 0 -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
        shell=True,
    )
    .decode("utf-8")
    .strip()
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)

# Wait until model is ready
for _ in range(10):
    with contextlib.suppress(Exception):
        assert triton_client.is_model_ready(model_name)
        break
    time.sleep(1)

Quindi esegui l'inferenza utilizzando il modello Triton Server:

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg")

Pulizia del container:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)

Ottimizzazione TensorRT (opzionale)

Per prestazioni ancora superiori, puoi utilizzare TensorRT con Triton Inference Server. TensorRT è un ottimizzatore di deep learning ad alte prestazioni, creato appositamente per le GPU NVIDIA, in grado di aumentare significativamente la velocità di inferenza.

I vantaggi principali dell'utilizzo di TensorRT con Triton includono:

Inferenza fino a 36 volte più veloce rispetto ai modelli non ottimizzati
Ottimizzazioni specifiche per l'hardware per la massima utilizzazione della GPU
Supporto per formati a precisione ridotta (INT8, FP16) mantenendo l'accuratezza
Fusione dei layer per ridurre il sovraccarico computazionale

Per utilizzare TensorRT direttamente, puoi esportare il tuo modello YOLO11 in formato TensorRT:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo11n.engine'

Per maggiori informazioni sull'ottimizzazione di TensorRT, consultare la guida all'integrazione di TensorRT.

Seguendo i passaggi sopra descritti, è possibile distribuire ed eseguire in modo efficiente i modelli Ultralytics YOLO11 su Triton Inference Server, fornendo una soluzione scalabile e ad alte prestazioni per le attività di inferenza di deep learning. In caso di problemi o ulteriori domande, fare riferimento alla documentazione ufficiale di Triton o rivolgersi alla community di Ultralytics per supporto.

FAQ

Come posso configurare Ultralytics YOLO11 con NVIDIA Triton Inference Server?

La configurazione di Ultralytics YOLO11 con NVIDIA Triton Inference Server prevede alcuni passaggi chiave:

Esporta YOLO11 in formato ONNX:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model

# Export the model to ONNX format
onnx_file = model.export(format="onnx", dynamic=True)

Configura il repository del modello Triton:

from pathlib import Path

# Define paths
model_name = "yolo"
triton_repo_path = Path("tmp") / "triton_repo"
triton_model_path = triton_repo_path / model_name

# Create directories
(triton_model_path / "1").mkdir(parents=True, exist_ok=True)
Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")
(triton_model_path / "config.pbtxt").touch()

Esegui il server Triton:

import contextlib
import subprocess
import time

from tritonclient.http import InferenceServerClient

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:24.09-py3"

subprocess.call(f"docker pull {tag}", shell=True)

container_id = (
    subprocess.check_output(
        f"docker run -d --rm --runtime=nvidia --gpus 0 -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
        shell=True,
    )
    .decode("utf-8")
    .strip()
)

triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)

for _ in range(10):
    with contextlib.suppress(Exception):
        assert triton_client.is_model_ready(model_name)
        break
    time.sleep(1)

Questa configurazione può aiutarti a distribuire in modo efficiente i modelli YOLO11 su larga scala su Triton Inference Server per l'inferenza di modelli AI ad alte prestazioni.

Quali vantaggi offre l'utilizzo di Ultralytics YOLO11 con NVIDIA Triton Inference Server?

L'integrazione di Ultralytics YOLO11 con NVIDIA Triton Inference Server offre diversi vantaggi:

Inferenza AI scalabile: Triton consente di servire più modelli da una singola istanza del server, supportando il caricamento e lo scaricamento dinamico dei modelli, rendendolo altamente scalabile per diversi carichi di lavoro AI.
Alte prestazioni: Ottimizzato per le GPU NVIDIA, Triton Inference Server garantisce operazioni di inferenza ad alta velocità, perfette per applicazioni in tempo reale come il rilevamento di oggetti.
Ensemble e versioning dei modelli: La modalità ensemble di Triton consente di combinare più modelli per migliorare i risultati, e il suo versioning dei modelli supporta i test A/B e gli aggiornamenti graduali.
Batching automatico: Triton raggruppa automaticamente più richieste di inferenza, migliorando significativamente il throughput e riducendo la latenza.
Distribuzione semplificata: Ottimizzazione graduale dei flussi di lavoro AI senza richiedere revisioni complete del sistema, facilitando un'efficiente scalabilità.

Per istruzioni dettagliate sulla configurazione e l'esecuzione di YOLO11 con Triton, è possibile consultare la guida alla configurazione.

Perché dovrei esportare il mio modello YOLO11 in formato ONNX prima di utilizzare Triton Inference Server?

L'utilizzo del formato ONNX (Open Neural Network Exchange) per il tuo modello Ultralytics YOLO11 prima di distribuirlo su NVIDIA Triton Inference Server offre diversi vantaggi chiave:

Interoperabilità: Il formato ONNX supporta il trasferimento tra diversi framework di deep learning (come PyTorch, TensorFlow), garantendo una compatibilità più ampia.
Ottimizzazione: Molti ambienti di deployment, incluso Triton, sono ottimizzati per ONNX, consentendo un'inferenza più rapida e prestazioni migliori.
Facilità di implementazione: ONNX è ampiamente supportato tra framework e piattaforme, semplificando il processo di implementazione in vari sistemi operativi e configurazioni hardware.
Indipendenza dal framework: Una volta convertito in ONNX, il tuo modello non è più legato al suo framework originale, il che lo rende più portatile.
Standardizzazione: ONNX fornisce una rappresentazione standardizzata che aiuta a superare i problemi di compatibilità tra diversi framework di IA.

Per esportare il tuo modello, usa:

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
onnx_file = model.export(format="onnx", dynamic=True)

È possibile seguire i passaggi nella guida all'integrazione ONNX per completare il processo.

Posso eseguire l'inferenza utilizzando il modello Ultralytics YOLO11 su Triton Inference Server?

Sì, puoi eseguire l'inferenza usando il modello Ultralytics YOLO11 su NVIDIA Triton Inference Server. Una volta che il tuo modello è impostato nel Triton Model Repository e il server è in esecuzione, puoi caricare ed eseguire l'inferenza sul tuo modello come segue:

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg")

Questo approccio consente di sfruttare le ottimizzazioni di Triton utilizzando al contempo la familiare interfaccia Ultralytics YOLO. Per una guida approfondita sulla configurazione e l'esecuzione di Triton Server con YOLO11, fare riferimento alla sezione sull'esecuzione del server di inferenza Triton.

Come si confronta Ultralytics YOLO11 con i modelli TensorFlow e PyTorch per il deployment?

Ultralytics YOLO11 offre diversi vantaggi unici rispetto ai modelli TensorFlow e PyTorch per la distribuzione:

Prestazioni in tempo reale: Ottimizzato per attività di rilevamento di oggetti in tempo reale, YOLO11 offre accuratezza e velocità all'avanguardia, rendendolo ideale per applicazioni che richiedono analisi video in diretta.
Facilità d'uso: YOLO11 si integra perfettamente con Triton Inference Server e supporta diversi formati di esportazione (ONNX, TensorRT, CoreML), rendendolo flessibile per vari scenari di implementazione.
Funzionalità avanzate: YOLO11 include funzionalità come il caricamento dinamico del modello, il controllo della versione del modello e l'inferenza di ensemble, che sono fondamentali per implementazioni di intelligenza artificiale scalabili e affidabili.
API semplificata: L'API Ultralytics fornisce un'interfaccia coerente tra diversi target di distribuzione, riducendo la curva di apprendimento e i tempi di sviluppo.
Ottimizzazione Edge: I modelli YOLO11 sono progettati pensando all'implementazione edge, offrendo prestazioni eccellenti anche su dispositivi con risorse limitate.

Per maggiori dettagli, confronta le opzioni di distribuzione nella guida all'esportazione del modello.

📅 Creato 1 anno fa ✏️ Aggiornato 8 giorni fa