Modifica la pagina su GitHub (EN)

Triton Inference Server con Ultralytics YOLO26

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



Watch: Getting Started with NVIDIA Triton Inference Server.

Cos'è Triton Inference Server?

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

  • Servire più modelli da una singola istanza di server
  • Caricamento e scaricamento dinamico dei modelli senza riavviare il server
  • Inferenza d'insieme (ensemble), che consente di utilizzare più modelli insieme per ottenere risultati
  • Controllo delle versioni del modello per A/B testing e aggiornamenti progressivi

Principali vantaggi di Triton Inference Server

Utilizzare Triton Inference Server con Ultralytics YOLO26 offre diversi vantaggi:

  • Batching automatico: raggruppa più richieste IA insieme prima di elaborarle, riducendo la latenza e migliorando la velocità di inferenza
  • Integrazione con Kubernetes: il design cloud-native funziona perfettamente con Kubernetes per la gestione e la scalabilità delle applicazioni IA
  • Ottimizzazioni specifiche per l'hardware: sfrutta appieno le GPU NVIDIA per le massime prestazioni
  • Flessibilità del framework: supporta molteplici framework IA, inclusi PyTorch, TensorFlow, ONNX, OpenVINO e TensorRT
  • Open source e personalizzabile: può essere modificato per soddisfare esigenze specifiche, garantendo flessibilità per varie applicazioni IA

Prerequisiti

Assicurati di avere i seguenti prerequisiti prima di procedere:

  • Docker o Podman installati sulla tua macchina
  • Installa ultralytics: 
    pip install ultralytics
  • Installa tritonclient: 
    pip install tritonclient[all]

Configurazione di Triton Inference Server

Esegui questo blocco di configurazione completo per esportare Ultralytics YOLO26 in ONNX, creare il repository dei modelli Triton e avviare Triton Inference Server:

Nota

Usa l'opzione runtime nello script per scegliere il tuo motore di container:

  • Imposta runtime = "docker" per Docker
  • Imposta runtime = "podman" per Podman
import contextlib
import subprocess
import time
from pathlib import Path

from tritonclient.http import InferenceServerClient

from ultralytics import YOLO

runtime = "docker"  # set to "podman" to use Podman

# 1) Exporting YOLO26 to ONNX Format

# Load a model
model = YOLO("yolo26n.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)

# 2) Setting Up Triton Model Repository

# 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)

# 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)

# 3) Running Triton Inference Server

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:26.02-py3"  # 16.17 GB (Compressed Size)

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

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus all"

container_name = "triton_server"

# Note: The :z flag on the volume mount is necessary for systems with SELinux (like Fedora/RHEL)
subprocess.call(
    f"{runtime} run -d --rm --name {container_name} {gpu_flags} -v {triton_repo_path.absolute()}:/models:z -p 8000:8000 {tag} tritonserver --model-repository=/models",
    shell=True,
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="127.0.0.1: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)

Esecuzione dell'inferenza

Esegui l'inferenza utilizzando il modello di Triton Server:

from ultralytics import YOLO

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

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

Pulisci il container (runtime e container_name sono definiti nel blocco di configurazione sopra):

import subprocess

runtime = "docker"  # set to "podman" to use Podman
container_name = "triton_server"  # Kill the named container
subprocess.call(f"{runtime} kill {container_name}", shell=True)

Ottimizzazione TensorRT (opzionale)

Per prestazioni ancora maggiori, puoi usare TensorRT con Triton Inference Server. TensorRT è un ottimizzatore di deep learning ad alte prestazioni costruito specificamente per le GPU NVIDIA che può aumentare significativamente la velocità di inferenza.

I principali vantaggi 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 il massimo utilizzo della GPU
  • Supporto per formati a precisione ridotta (INT8, FP16) mantenendo l'accuratezza
  • Fusione dei layer per ridurre il sovraccarico computazionale

Per utilizzare direttamente TensorRT, puoi esportare il tuo modello Ultralytics YOLO26 nel formato TensorRT:

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

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

Per ulteriori informazioni sull'ottimizzazione con TensorRT, consulta la guida all'integrazione di TensorRT.

Seguendo i passaggi precedenti, puoi distribuire ed eseguire i modelli Ultralytics YOLO26 in modo efficiente su Triton Inference Server, fornendo una soluzione scalabile e ad alte prestazioni per le attività di inferenza di deep learning. Se riscontri problemi o hai ulteriori domande, consulta la documentazione ufficiale di Triton o contatta la community di Ultralytics per ricevere supporto.

FAQ

Come posso configurare Ultralytics YOLO26 con NVIDIA Triton Inference Server?

La configurazione di Ultralytics YOLO26 con NVIDIA Triton Inference Server comporta alcuni passaggi chiave:

  1. Esporta YOLO26 nel formato ONNX:

    from ultralytics import YOLO

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

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

  2. Configura il repository dei modelli 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()

  3. Avvia 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:26.02-py3"

runtime = "docker"  # set to "podman" to use Podman
subprocess.call(f"{runtime} pull {tag}", shell=True)

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus all"

container_name = "triton_server"
subprocess.call(
    f"{runtime} run -d --rm --name {container_name} {gpu_flags} -v {triton_repo_path.absolute()}:/models:z -p 8000:8000 {tag} tritonserver --model-repository=/models",
    shell=True,
)

triton_client = InferenceServerClient(url="127.0.0.1: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 Ultralytics YOLO26 su larga scala su Triton Inference Server per un'inferenza di modelli IA ad alte prestazioni.

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

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

  • Inferenza IA scalabile: Triton consente di servire più modelli da una singola istanza di server, supportando il caricamento e lo scaricamento dinamico dei modelli, rendendolo altamente scalabile per diversi carichi di lavoro IA.
  • 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 controllo delle versioni del modello: la modalità ensemble di Triton consente di combinare più modelli per migliorare i risultati e il controllo delle versioni dei modelli supporta A/B testing e aggiornamenti progressivi.
  • Batching automatico: Triton raggruppa automaticamente più richieste di inferenza insieme, migliorando significativamente il throughput e riducendo la latenza.
  • Distribuzione semplificata: ottimizzazione graduale dei flussi di lavoro IA senza richiedere revisioni complete del sistema, rendendo più facile scalare in modo efficiente.

Per istruzioni dettagliate su come configurare ed eseguire Ultralytics YOLO26 con Triton, fai riferimento a Configurazione di Triton Inference Server e Esecuzione dell'inferenza.

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

L'utilizzo del formato ONNX (Open Neural Network Exchange) per il tuo modello Ultralytics YOLO26 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 maggiore compatibilità.
  • Ottimizzazione: molti ambienti di distribuzione, incluso Triton, sono ottimizzati per ONNX, consentendo un'inferenza più rapida e prestazioni migliori.
  • Facilità di distribuzione: ONNX è ampiamente supportato tra framework e piattaforme, semplificando il processo di distribuzione 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, rendendolo più portabile.
  • Standardizzazione: ONNX fornisce una rappresentazione standardizzata che aiuta a superare i problemi di compatibilità tra diversi framework IA.

Per esportare il tuo modello, utilizza:

from ultralytics import YOLO

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

Puoi seguire i passaggi nella guida all'integrazione di ONNX per completare il processo.

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

Sì, puoi eseguire l'inferenza utilizzando il modello Ultralytics YOLO26 su NVIDIA Triton Inference Server. Una volta che il tuo modello è configurato nel repository dei modelli Triton 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://127.0.0.1:8000/yolo", task="detect")

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

Questo approccio ti consente di sfruttare le ottimizzazioni di Triton utilizzando la familiare interfaccia Ultralytics YOLO.

Come si confronta Ultralytics YOLO26 con i modelli TensorFlow e PyTorch per la distribuzione?

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

  • Prestazioni in tempo reale: ottimizzato per attività di rilevamento oggetti in tempo reale, Ultralytics YOLO26 fornisce accuratezza e velocità all'avanguardia, rendendolo ideale per applicazioni che richiedono analisi video dal vivo.
  • Facilità d'uso: Ultralytics YOLO26 si integra perfettamente con Triton Inference Server e supporta diversi formati di esportazione (ONNX, TensorRT), rendendolo flessibile per vari scenari di distribuzione.
  • Funzionalità avanzate: Ultralytics YOLO26 include funzionalità come caricamento dinamico del modello, controllo delle versioni e inferenza d'insieme, cruciali per distribuzioni IA scalabili e affidabili.
  • API semplificata: l'API di Ultralytics fornisce un'interfaccia coerente tra diversi target di distribuzione, riducendo la curva di apprendimento e i tempi di sviluppo.
  • Ottimizzazione Edge: i modelli Ultralytics YOLO26 sono progettati pensando alla distribuzione edge, offrendo prestazioni eccellenti anche su dispositivi con risorse limitate.

Per ulteriori dettagli, confronta le opzioni di distribuzione nella guida all'esportazione dei modelli.

Contributors
Modifica la pagina su GitHub (EN)
GLglenn-jocher17Y-Y-T-G4ONonuralpszr2LEleonnil1

Commenti