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 dans le cloud optimisée pour les GPU NVIDIA. Triton simplifie le déploiement de modèles d'IA à l'échelle dans la 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:

  pip install tritonclient[all]
  

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.

1. Crée la structure de répertoire nécessaire :

   from pathlib import Path
   
   # Define paths
   triton_repo_path = Path('tmp') / 'triton_repo'
   triton_model_path = triton_repo_path / 'yolo'
   
   # Create directories
   (triton_model_path / '1').mkdir(parents=True, exist_ok=True)
   

2. Déplace le modèle exporté ONNX vers le référentiel Triton :

   from pathlib import Path
   
   # 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()
   

Exécuter Triton Inference Server

Exécute le serveur d'inférence Triton à l'aide de Docker :

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(f'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.

Commentaires