Triton Serveur d'inférence avec Ultralytics YOLOv8
Le serveur d'inférenceTriton (anciennement connu sous le nom de TensorRT Inference Server) est une solution logicielle open-source développée par NVIDIA. Il fournit une solution d'inférence en nuage optimisée pour les GPU NVIDIA . Triton simplifie le déploiement de modèles d'IA à l'échelle en production. L'intégration de Ultralytics YOLOv8 avec Triton Inference Server permet de déployer des charges de travail d'inférence d'apprentissage profond évolutives et très performantes. Ce guide fournit les étapes pour configurer et tester l'intégration.
Regarde : DĂ©marrer avec 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 d'apprentissage profond et d'apprentissage automatique, notamment TensorFlow, PyTorch, ONNX Runtime, 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.
- L'inférence d'ensemble, qui permet d'utiliser plusieurs modèles ensemble pour obtenir des résultats.
- Modélisation des versions pour les tests A/B et les mises à jour en continu.
Conditions préalables
Assure-toi d'avoir les prérequis suivants avant de continuer :
- Docker installé sur ta machine.
- Installer
tritonclient
:
Exportation de YOLOv8 au format ONNX
Avant de déployer le modèle sur Triton, il doit être exporté au format ONNX . ONNX (Open Neural Network Exchange) est un format qui permet de transférer des modèles entre différents frameworks d'apprentissage profond. Utilise le format export
de la fonction YOLO
classe :
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # load an official model
# Export the model
onnx_file = model.export(format="onnx", dynamic=True)
Configuration du référentiel de modèles Triton
Le dépôt de modèles Triton est un lieu de stockage où Triton peut accéder à des modèles et les charger.
-
Crée la structure de répertoire nécessaire :
-
Déplace le modèle exporté ONNX vers le référentiel Triton :
Exécuter Triton Inference Server
Exécute le serveur d'inférence Triton à l'aide de Docker :
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:23.09-py3" # 6.4 GB
# Pull the image
subprocess.call(f"docker pull {tag}", shell=True)
# Run the Triton server and capture the container ID
container_id = (
subprocess.check_output(
f"docker run -d --rm -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
shell=True,
)
.decode("utf-8")
.strip()
)
# Wait for the Triton server to start
triton_client = InferenceServerClient(url="localhost: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)
Lance ensuite l'inférence à l'aide du modèle du serveur Triton :
from ultralytics import YOLO
# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")
# Run inference on the server
results = model("path/to/image.jpg")
Nettoie le récipient :
# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)
En suivant les étapes ci-dessus, tu peux déployer et exécuter efficacement les modèles Ultralytics YOLOv8 sur Triton Inference Server, ce qui constitue une solution évolutive et performante pour les tâches d'inférence de l'apprentissage profond. Si tu rencontres des problèmes ou si tu as d'autres questions, reporte-toi à la documentation officielle Triton ou contacte la communauté Ultralytics pour obtenir de l'aide.
FAQ
Comment configurer Ultralytics YOLOv8 avec NVIDIA Triton Inference Server ?
La mise en place Ultralytics YOLOv8 avec NVIDIA Triton Inference Server comporte quelques étapes clés :
-
Exporte YOLOv8 au format ONNX :
-
Configure le référentiel de modèles 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()
-
Exécute le serveur 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:23.09-py3" subprocess.call(f"docker pull {tag}", shell=True) container_id = ( subprocess.check_output( f"docker run -d --rm -v {triton_repo_path}/models -p 8000:8000 {tag} tritonserver --model-repository=/models", shell=True, ) .decode("utf-8") .strip() ) triton_client = InferenceServerClient(url="localhost: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 les modèles YOLOv8 à grande échelle sur Triton Inference Server pour une inférence de modèle d'IA très performante.
Quels sont les avantages de l'utilisation de Ultralytics YOLOv8 avec NVIDIA Triton Inference Server ?
L'intégration Ultralytics YOLOv8 avec NVIDIA Triton Inference Server offre plusieurs avantages :
- Inférence 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 des modèles, ce qui le rend très évolutif pour diverses charges de travail d'IA.
- Haute performance: Optimisé pour les GPU NVIDIA , Triton Inference Server assure des opérations d'inférence à grande vitesse, parfaites pour les applications en temps réel telles que la détection d'objets.
- Ensemble et version de modèle: le mode ensemble de Triton permet de combiner plusieurs modèles pour améliorer les résultats, et sa version de modèle prend en charge les tests A/B et les mises à jour en continu.
Pour obtenir des instructions détaillées sur la configuration et le fonctionnement de YOLOv8 avec Triton, tu peux te référer au guide d'installation.
Pourquoi dois-je exporter mon modèle YOLOv8 au format ONNX avant d'utiliser le serveur d'inférence Triton ?
L'utilisation du format ONNX (Open Neural Network Exchange) pour ton modèle avant de le déployer sur le serveur d'inférence offre plusieurs avantages. Ultralytics YOLOv8 modèle avant de le déployer sur NVIDIA Triton Inference Server offre plusieurs avantages importants :
- Interopérabilité: le format ONNX prend en charge le transfert entre différents cadres d'apprentissage profond (tels que PyTorch, TensorFlow), garantissant ainsi une plus grande compatibilité.
- Optimisation: De nombreux environnements de déploiement, y compris Triton, optimisent 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 cadres et les plateformes, ce qui simplifie le processus de déploiement dans divers systèmes d'exploitation et configurations matérielles.
Pour exporter ton modèle, utilise :
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
onnx_file = model.export(format="onnx", dynamic=True)
Tu peux suivre les Ă©tapes du guide d'exportation pour terminer le processus.
Puis-je effectuer une inférence à l'aide du modèle Ultralytics YOLOv8 sur le serveur d'inférence Triton ?
Oui, tu peux faire de l'inférence en utilisant le Ultralytics YOLOv8 sur NVIDIA Triton Inference Server. Une fois que ton modèle est configuré dans le référentiel de modèles Triton et que le serveur fonctionne, tu peux charger et exécuter l'inférence sur ton modèle comme suit :
from ultralytics import YOLO
# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")
# Run inference on the server
results = model("path/to/image.jpg")
Pour un guide détaillé sur l'installation et l'utilisation du serveur Triton avec YOLOv8, reporte-toi à la section sur l'utilisation du serveur d'inférence triton .
Comment Ultralytics YOLOv8 se compare-t-il aux modèles TensorFlow et PyTorch pour le déploiement ?
Ultralytics YOLOv8 offre plusieurs avantages uniques par rapport aux modèles de déploiement TensorFlow et PyTorch :
- Performance en temps réel: Optimisé pour les tâches de détection d'objets en temps réel, YOLOv8 offre une précision et une vitesse de pointe, ce qui le rend idéal pour les applications nécessitant une analyse vidéo en direct.
- Facilité d'utilisation: YOLOv8 s'intègre parfaitement à Triton Inference Server et prend en charge divers formats d'exportation (ONNX, TensorRT, CoreML), ce qui le rend flexible pour divers scénarios de déploiement.
- Fonctionnalités avancées: YOLOv8 comprend des fonctionnalités telles que le chargement dynamique de modèles, le versionnage de modèles et l'inférence d'ensemble, qui sont cruciales pour des déploiements d'IA évolutifs et fiables.
Pour plus de détails, compare les options de déploiement dans le guide de déploiement du modèle.