Triton Inference Server avec Ultralytics YOLO26#
Le Triton Inference Server (anciennement connu sous le nom de TensorRT Inference Server) est une solution logicielle open source développée par NVIDIA. Il offre 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. Intégrer Ultralytics YOLO26 à Triton Inference Server te permet de déployer des charges de travail d'inférence deep learning évolutives et hautes performances. Ce guide fournit 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 une variété de 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 :
- Servir plusieurs modèles à partir d'une seule instance de serveur
- Chargement et déchargement dynamiques de modèles sans redémarrage du serveur
- Inférence d'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
Avantages clés de Triton Inference Server#
L'utilisation de Triton Inference Server avec Ultralytics YOLO26 présente plusieurs avantages :
- Batching automatique : Regroupe plusieurs requêtes d'IA avant de les traiter, réduisant la latence et améliorant la vitesse d'inférence
- Intégration Kubernetes : Sa conception cloud-native fonctionne parfaitement avec Kubernetes pour gérer et mettre à l'échelle les applications d'IA
- Optimisations spécifiques au matériel : Tire pleinement parti des GPU NVIDIA pour une performance maximale
- 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, garantissant une flexibilité pour diverses applications d'IA
Prérequis#
Assure-toi d'avoir les prérequis suivants avant de continuer :
- Docker (>= 28.2.0, avec NVIDIA Container Toolkit >= 1.18 pour l'accès CDI aux GPU) 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 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 conteneur :
- 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 en utilisant le 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 (Optionnel)#
Pour des performances encore plus élevées, tu peux utiliser TensorRT avec Triton Inference Server. TensorRT est un optimisateur de deep learning haute performance 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 incluent :
- Inférence jusqu'à 36 fois plus rapide par rapport aux 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 maintenant la précision
- Fusion de couches pour réduire la surcharge de calcul
Pour utiliser directement TensorRT, 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 désormais déployer et exécuter des modèles Ultralytics YOLO26 sur Triton Inference Server pour 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#
L'intégration d'Ultralytics YOLO26 avec NVIDIA Triton Inference Server offre plusieurs avantages :
- Inférence d'IA évolutive : Triton permet de servir plusieurs modèles à partir d'une seule instance de serveur, en prenant en charge le chargement et le déchargement dynamiques de modèles, ce qui le rend hautement évolutif pour diverses charges de travail d'IA.
- Haute performance : Optimisé pour les GPU NVIDIA, Triton Inference Server garantit des opérations d'inférence à haute vitesse, parfaites pour les applications en temps réel telles que la détection d'objets.
- Ensemble et versionnage de modèles : Le mode ensemble de Triton permet de combiner plusieurs modèles pour améliorer les résultats, et son versionnage de modèles prend en charge les tests A/B et les mises à jour progressives.
- Batching automatique : Triton regroupe automatiquement plusieurs requêtes d'inférence, améliorant considérablement le débit et réduisant la latence.
- Déploiement simplifié : Optimisation progressive des flux de travail d'IA sans nécessiter de refonte complète du système, facilitant une mise à l'échelle efficace.
Pour 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 (Open Neural Network Exchange) pour ton modèle Ultralytics YOLO26 avant de le déployer sur NVIDIA Triton Inference Server offre plusieurs avantages clés :
- Interopérabilité : Le format ONNX prend en charge le transfert entre différents frameworks de deep learning (tels que PyTorch, TensorFlow), garantissant une compatibilité plus large.
- Optimisation : De nombreux environnements de déploiement, y compris Triton, optimisent pour ONNX, permettant 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, simplifiant le processus de déploiement dans divers systèmes d'exploitation et configurations matérielles.
- Indépendance vis-à-vis des frameworks : Une fois converti en 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 à surmonter 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 mener à bien le processus.
Oui, tu peux exécuter des inférences à l'aide du 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 en cours d'exécution, tu peux charger ton modèle et exécuter des inférences de la manière suivante :
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 de l'analyse vidéo en direct.
- Facilité d'utilisation : Ultralytics YOLO26 s'intègre de manière transparente à 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 : Ultralytics YOLO26 inclut des fonctionnalités telles que le chargement dynamique de modèles, le versionnage de modèles et l'inférence en ensemble, qui sont essentielles pour des déploiements d'IA évolutifs et fiables.
- API simplifiée : L'API Ultralytics fournit une interface cohérente à travers différentes cibles de déploiement, réduisant la courbe d'apprentissage et le temps de développement.
- Optimisation pour la périphérie (Edge) : Les modèles Ultralytics YOLO26 sont conçus en pensant au déploiement 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 implique quelques étapes clés :
Exporter YOLO26 au format ONNX :
Configurer le dépôt de modèles Triton :
Exécuter le serveur Triton :
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.