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 AI su larga scala in produzione. L'integrazione di Ultralytics YOLO26 con Triton Inference Server 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.
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 un'ampia gamma di framework di deep learning e machine learning, inclusi PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT e molti altri. I suoi casi d'uso principali 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 di Triton Inference Server con Ultralytics YOLO26 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 molteplici framework AI inclusi PyTorch, TensorFlow, ONNX, OpenVINO 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 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, costruire il repository del modello Triton e avviare il Triton Inference Server:
Nota
Utilizzare il runtime opzione 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 del 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")
Pulire il container (runtime e container_name sono definiti nel blocco di setup soprastante):
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 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 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 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, è possibile esportare il 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 maggiori informazioni sull'ottimizzazione di TensorRT, consultare la guida all'integrazione di TensorRT.
Seguendo i passaggi precedenti, puoi deploy e eseguire i modelli Ultralytics YOLO26 in modo efficiente su Triton Inference Server, fornendo una soluzione scalabile e ad alte prestazioni per i task 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 supporto.
FAQ
Come si configura Ultralytics YOLO26 con NVIDIA Triton Inference Server?
La configurazione di Ultralytics YOLO26 con NVIDIA Triton Inference Server prevede alcuni passaggi chiave:
Esporta YOLO26 in 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)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: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 modelli Ultralytics YOLO26 su larga scala su Triton Inference Server per l'inferenza di modelli AI 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 numerosi 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 Ultralytics YOLO26 con Triton, fare riferimento a Setting Up Triton Inference Server e Running Inference.
Perché dovrei esportare il mio modello YOLO26 in 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 implementarlo 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("yolo26n.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 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 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://127.0.0.1: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 l'interfaccia familiare di Ultralytics YOLO.
Come si confronta Ultralytics YOLO26 con i modelli TensorFlow e PyTorch per il deployment?
Ultralytics YOLO26 offre numerosi vantaggi unici rispetto ai modelli TensorFlow e PyTorch per il deployment:
- Prestazioni in Tempo Reale: Ottimizzato per attività di detect di oggetti in tempo reale, Ultralytics YOLO26 offre precisione e velocità all'avanguardia, rendendolo ideale per applicazioni che richiedono analisi video in diretta.
- 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 deployment.
- Funzionalità Avanzate: Ultralytics YOLO26 include funzionalità come il caricamento dinamico del modello, il versioning del modello e l'inferenza d'insieme, che sono cruciali per implementazioni AI 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 Ultralytics YOLO26 sono progettati pensando al deployment edge, offrendo prestazioni eccellenti anche su dispositivi con risorse limitate.
Per maggiori dettagli, confronta le opzioni di distribuzione nella guida all'esportazione del modello.
