Triton Inference Server avec Ultralytics YOLO26#
Le Triton Inference Server (anciennement appelé TensorRT Inference Server) est une solution logicielle open source développée par NVIDIA. Il fournit une solution d’inférence dans le cloud optimisée pour les GPU NVIDIA. Triton simplifie le déploiement de modèles d’IA à grande échelle en production. L’intégration d’Ultralytics YOLO26 avec Triton Inference Server te permet de déployer des charges de travail d’inférence évolutives et hautes performances en apprentissage profond. Ce guide présente les étapes pour configurer et tester l’intégration.
À regarder : Premiers pas avec NVIDIA Triton Inference Server.
Qu’est-ce que Triton Inference Server ?#
Triton Inference Server est conçu pour déployer différents modèles d’IA en production. Il prend en charge un large éventail de frameworks de deep learning et de machine learning, notamment PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT et bien d’autres. Ses principaux cas d’utilisation sont les suivants :
- Hébergement de plusieurs modèles sur une même instance de serveur
- Chargement et déchargement dynamiques des modèles sans redémarrer le serveur
- Inférence en ensemble, permettant d’utiliser plusieurs modèles ensemble pour obtenir des résultats
- Gestion des versions de modèles pour les tests A/B et les mises à jour progressives
Principaux avantages de Triton Inference Server#
L’utilisation de Triton Inference Server avec Ultralytics YOLO26 présente plusieurs avantages :
- Traitement par lots automatique : regroupe plusieurs requêtes d’IA avant de les traiter, ce qui réduit la latence et accélère l’inférence.
- Intégration à Kubernetes : sa conception cloud native s’intègre parfaitement à Kubernetes pour gérer et faire évoluer les applications d’IA.
- Optimisations propres au matériel : tire pleinement parti des GPU NVIDIA pour des performances maximales.
- Souplesse des frameworks : prend en charge plusieurs frameworks d’IA, notamment PyTorch, TensorFlow, ONNX, OpenVINO et TensorRT.
- Open source et personnalisable : peut être modifié pour répondre à des besoins précis, offrant ainsi de la souplesse pour diverses applications d’IA.
Prérequis#
Avant de continuer, vérifie que tu disposes des prérequis suivants :
- Docker (>= 28.2.0, avec NVIDIA Container Toolkit >= 1.18 pour l’accès GPU via CDI) ou Podman installé sur ta machine
- Installe
ultralytics:pip install ultralytics - Installe
tritonclient:pip install tritonclient[all]
Configuration de Triton Inference Server#
Exécute ce bloc de configuration complet pour exporter Ultralytics YOLO26 au format ONNX, créer le dépôt de modèles Triton et démarrer Triton Inference Server :
Utilise l’option runtime dans le script pour choisir ton moteur de conteneurs :
- Définis
runtime = "docker"pour Docker - Définis
runtime = "podman"pour 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"
}
}
# Enable TensorRT acceleration (requires a GPU and TensorRT-enabled Triton; remove this block for CPU-only serving)
# The 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)
# CDI GPU request works identically on Docker and Podman
gpu_flags = "--device nvidia.com/gpu=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)Exécution de l’inférence#
Lance l’inférence à l’aide du modèle Triton Server :
from ultralytics import YOLO
# Charger le modèle Triton Server
model = YOLO("http://127.0.0.1:8000/yolo", task="detect")
# Exécuter l’inférence sur le serveur
results = model("path/to/image.jpg")Nettoie le conteneur :
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)Optimisation TensorRT (facultatif)#
Pour obtenir des performances encore meilleures, tu peux utiliser TensorRT avec Triton Inference Server. TensorRT est un optimiseur de deep learning hautes performances, conçu spécifiquement pour les GPU NVIDIA, qui peut considérablement accélérer l’inférence.
Voici les principaux avantages de l’utilisation de TensorRT avec Triton :
- Inférence jusqu’à 36 fois plus rapide que les modèles non optimisés
- Optimisations propres au matériel pour une utilisation maximale du GPU
- Prise en charge des formats à précision réduite (INT8, FP16) sans perte de précision
- Fusion de couches pour réduire la charge de calcul
Le config.pbtxt ci-dessus active déjà l’accélérateur TensorRT de Triton pour le modèle ONNX. Pour utiliser directement TensorRT avec Ultralytics, exporte ton modèle Ultralytics YOLO26 au format TensorRT :
from ultralytics import YOLO
# Charger le modèle YOLO26
model = YOLO("yolo26n.pt")
# Exporter le modèle au format TensorRT
model.export(format="engine") # crée 'yolo26n.engine'Pour en savoir plus sur l’optimisation TensorRT, consulte le guide d’intégration TensorRT.
Tu peux maintenant déployer et exécuter des modèles Ultralytics YOLO26 sur Triton Inference Server pour bénéficier d’une inférence évolutive et haute performance. Pour plus de détails, consulte la documentation officielle de Triton ou demande de l’aide à la communauté Ultralytics.
FAQ#
La configuration d’Ultralytics YOLO26 avec NVIDIA Triton Inference Server comporte quelques étapes clés :
-
Exporte YOLO26 au format ONNX :
from ultralytics import YOLO # Charger un modèle model = YOLO("yolo26n.pt") # charger un modèle officiel # Exporter le modèle au format ONNX onnx_file = model.export(format="onnx", dynamic=True) -
Configure le dépôt de modèles Triton :
from pathlib import Path # Définir les chemins model_name = "yolo" triton_repo_path = Path("tmp") / "triton_repo" triton_model_path = triton_repo_path / model_name # Créer les répertoires (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() -
Lance Triton Server :
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) # CDI GPU request works identically on Docker and Podman gpu_flags = "--device nvidia.com/gpu=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)
Cette configuration peut t’aider à déployer efficacement des modèles Ultralytics YOLO26 à grande échelle sur Triton Inference Server pour une inférence de modèles d’IA haute performance.
-
L’intégration d’Ultralytics YOLO26 avec NVIDIA Triton Inference Server présente plusieurs avantages :
- Inférence d’IA évolutive : Triton permet d’héberger plusieurs modèles sur une seule instance de serveur et prend en charge le chargement et le déchargement dynamiques des modèles, ce qui le rend très évolutif pour divers types de charges de travail d’IA.
- Hautes performances : optimisé pour les GPU NVIDIA, Triton Inference Server garantit une inférence rapide, idéale pour les applications en temps réel telles que la détection d’objets.
- Ensembles et gestion des versions de modèles : le mode ensemble de Triton permet de combiner plusieurs modèles pour améliorer les résultats, et la gestion des versions prend en charge les tests A/B et les mises à jour progressives.
- Traitement par lots automatique : Triton regroupe automatiquement plusieurs requêtes d’inférence, ce qui améliore considérablement le débit et réduit la latence.
- Déploiement simplifié : optimise progressivement les flux de travail d’IA sans nécessiter de refonte complète du système, ce qui facilite une mise à l’échelle efficace.
Pour obtenir des instructions détaillées sur la configuration et l’exécution d’Ultralytics YOLO26 avec Triton, consulte Configuration de Triton Inference Server et Exécution de l’inférence.
L’utilisation du format ONNX (échange de réseaux neuronaux ouverts) pour ton modèle Ultralytics YOLO26 avant son déploiement sur NVIDIA Triton Inference Server présente plusieurs avantages clés :
- Interopérabilité : le format ONNX permet le transfert entre différents frameworks de deep learning (tels que PyTorch et TensorFlow), assurant une compatibilité plus étendue.
- Optimisation : de nombreux environnements de déploiement, dont Triton, sont optimisés pour ONNX, ce qui permet une inférence plus rapide et de meilleures performances.
- Facilité de déploiement : ONNX est largement pris en charge par les frameworks et les plateformes, ce qui simplifie le déploiement sur différents systèmes d’exploitation et configurations matérielles.
- Indépendance vis-à-vis des frameworks : une fois converti au format ONNX, ton modèle n’est plus lié à son framework d’origine et devient ainsi plus portable.
- Normalisation : ONNX fournit une représentation normalisée qui aide à résoudre les problèmes de compatibilité entre différents frameworks d’IA.
Pour exporter ton modèle, utilise :
from ultralytics import YOLO model = YOLO("yolo26n.pt") onnx_file = model.export(format="onnx", dynamic=True)Tu peux suivre les étapes du guide d’intégration d’ONNX pour terminer le processus.
Oui, tu peux effectuer des inférences avec le modèle Ultralytics YOLO26 sur NVIDIA Triton Inference Server. Une fois ton modèle configuré dans le dépôt de modèles Triton et le serveur démarré, tu peux charger ton modèle et effectuer des inférences comme suit :
from ultralytics import YOLO # Charger le modèle Triton Server model = YOLO("http://127.0.0.1:8000/yolo", task="detect") # Exécuter l’inférence sur le serveur results = model("path/to/image.jpg")Cette approche te permet de tirer parti des optimisations de Triton tout en utilisant l’interface Ultralytics YOLO que tu connais.
Ultralytics YOLO26 offre plusieurs avantages distinctifs par rapport aux modèles TensorFlow et PyTorch pour le déploiement :
- Performances en temps réel : Optimisé pour les tâches de détection d’objets en temps réel, Ultralytics YOLO26 offre une précision et une vitesse de pointe, ce qui le rend idéal pour les applications nécessitant l’analyse vidéo en direct.
- Facilité d’utilisation : Ultralytics YOLO26 s’intègre parfaitement à Triton Inference Server et prend en charge divers formats d’exportation (ONNX, TensorRT), ce qui le rend adaptable à différents scénarios de déploiement.
- Fonctionnalités avancées : Le service via Triton ajoute le chargement dynamique des modèles, la gestion de leurs versions et l’inférence en ensemble, des capacités essentielles pour des déploiements d’IA évolutifs et fiables.
- API simplifiée : L’API Ultralytics offre une interface cohérente sur différentes cibles de déploiement, réduisant ainsi le temps d’apprentissage et de développement.
- Optimisation pour l’edge : Les modèles Ultralytics YOLO26 sont conçus pour le déploiement en périphérie et offrent d’excellentes performances même sur des appareils aux ressources limitées.
Pour en savoir plus, compare les options de déploiement dans le guide d’exportation des modèles.