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 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 à Triton Inference Server te permet de déployer des charges de travail d’inférence d’apprentissage profond évolutives et hautement performantes. Ce guide présente les étapes pour configurer et tester l’intégration.
Watch: Getting Started with 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 d’apprentissage profond et d’apprentissage automatique, notamment PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT et bien d’autres. Ses principaux cas d’utilisation sont les suivants :
- Fournir plusieurs modèles depuis une seule instance de serveur
- Charger et décharger dynamiquement des modèles sans redémarrer le serveur
- Effectuer des inférences par ensemble, en permettant d’utiliser plusieurs modèles conjointement pour obtenir des résultats
- Gérer les versions des 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 offre plusieurs avantages :
- Regroupement automatique : regroupe plusieurs requêtes d’IA avant leur traitement, ce qui réduit la latence et accélère l’inférence
- Intégration à Kubernetes : sa conception cloud native fonctionne parfaitement avec Kubernetes pour gérer et faire évoluer les applications d’IA
- Optimisations spécifiques au matériel : exploite pleinement les GPU NVIDIA pour des performances maximales
- Flexibilité 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 spécifiques, ce qui garantit une grande flexibilité pour diverses applications d’IA
Prérequis#
Vérifie que les prérequis suivants sont installés avant de continuer :
- Docker (>= 28.2.0, avec NVIDIA Container Toolkit >= 1.18 pour l’accès aux 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 vers ONNX, créer le référentiel 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#
Exécute l’inférence à l’aide du modèle 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")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 des performances encore meilleures, tu peux utiliser TensorRT avec Triton Inference Server. TensorRT est un optimiseur d’apprentissage profond hautes performances conçu spécifiquement pour les GPU NVIDIA, qui peut augmenter considérablement la vitesse d’inférence.
Les principaux avantages de l’utilisation de TensorRT avec Triton sont les suivants :
- Inférence jusqu’à 36 fois plus rapide qu’avec des modèles non optimisés
- Optimisations spécifiques au matériel pour une utilisation maximale du GPU
- Prise en charge des formats à précision réduite (INT8, FP16) tout en conservant la précision
- Fusion des couches pour réduire la surcharge de calcul
Pour utiliser TensorRT directement, tu peux exporter ton modèle Ultralytics YOLO26 au format 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'Pour plus d’informations 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 effectuer des inférences évolutives et hautement performantes. Pour plus de détails, consulte la documentation officielle de Triton ou demande de l’aide à la communauté Ultralytics.
FAQ#
L’intégration d’Ultralytics YOLO26 à NVIDIA Triton Inference Server offre plusieurs avantages :
- Inférence d’IA évolutive : Triton permet de servir plusieurs modèles depuis 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 diverses charges de travail d’IA.
- Hautes performances : optimisé pour les GPU NVIDIA, Triton Inference Server garantit des opérations d’inférence rapides, parfaitement adaptées aux applications en temps réel telles que la détection d’objets.
- Ensembles et gestion des versions des modèles : le mode ensemble de Triton permet de combiner plusieurs modèles pour améliorer les résultats, tandis que la gestion des versions prend en charge les tests A/B et les mises à jour progressives.
- Regroupement 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 workflows d’IA sans nécessiter de refonte complète des systèmes, 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 offre plusieurs avantages clés :
- Interopérabilité : le format ONNX permet le transfert entre différents frameworks d’apprentissage profond (comme PyTorch et TensorFlow), ce qui garantit une compatibilité plus étendue.
- Optimisation : de nombreux environnements de déploiement, notamment 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 processus de 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, ce qui le rend plus portable.
- Standardisation : ONNX fournit une représentation standardisé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 ONNX pour terminer le processus.
Oui, tu peux exécuter des inférences avec le modèle Ultralytics YOLO26 sur NVIDIA Triton Inference Server. Une fois ton modèle configuré dans le référentiel de modèles Triton et le serveur démarré, tu peux charger et exécuter des inférences avec ton modèle comme suit :
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")Cette approche te permet de tirer parti des optimisations de Triton tout en utilisant l’interface familière d’Ultralytics YOLO.
Ultralytics YOLO26 offre plusieurs avantages uniques 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 de vidéos 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 flexible pour différents scénarios de déploiement.
- Fonctionnalités avancées : Le service via Triton ajoute le chargement dynamique de modèles, le versionnage de modèles et l'inférence en ensemble, qui sont essentiels pour des déploiements d'IA évolutifs et fiables.
- API simplifiée : l’API Ultralytics fournit une interface cohérente entre différentes cibles de déploiement, ce qui réduit le temps d’apprentissage et de développement.
- Optimisation pour l’edge : les modèles Ultralytics YOLO26 sont conçus pour être déployés en périphérie, offrant d’excellentes performances même sur des appareils aux ressources limitées.
Pour plus de détails, compare les options de déploiement dans le guide d’exportation des modèles.
La configuration d’Ultralytics YOLO26 avec NVIDIA Triton Inference Server comporte quelques étapes clés :
Exporter YOLO26 au format ONNX :
Configurer le référentiel de modèles Triton :
Exécuter Triton Server :
Cette configuration peut t’aider à déployer efficacement à grande échelle des modèles Ultralytics YOLO26 sur Triton Inference Server pour effectuer des inférences de modèles d’IA hautement performantes.