Serveur d'inférence Triton avec Ultralytics YOLO11

Q: How do I set up Ultralytics YOLO11 with NVIDIA Triton Inference Server?

La configuration d'Ultralytics YOLO11 avec NVIDIA Triton Inference Server implique quelques étapes clés : Cette configuration peut vous aider à déployer efficacement des modèles YOLO11 à l'échelle sur Triton Inference Server pour une inférence de modèle d'IA à haute performance.

Le Triton Inference Server (anciennement 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 YOLO11 avec Triton Inference Server vous permet de déployer des charges de travail d'inférence de deep learning évolutives et performantes. Ce guide fournit les étapes pour configurer et tester l'intégration.

Regarder : Démarrage avec le serveur d'inférence NVIDIA Triton.

Qu'est-ce que Triton Inference Server ?

Le serveur d'inférence Triton 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 automatique et d'apprentissage profond, notamment TensorFlow, PyTorch, ONNX Runtime et bien d'autres. Ses principaux cas d'utilisation sont les suivants :

Servir plusieurs modèles à partir d'une seule instance de serveur
Chargement et déchargement dynamiques du modèle 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

Principaux avantages de Triton Inference Server

L'utilisation de Triton Inference Server avec Ultralytics YOLO11 offre plusieurs avantages :

Batching automatique : Regroupe plusieurs requêtes d’IA avant de les traiter, réduisant ainsi la latence et améliorant la vitesse d’inférence
Intégration Kubernetes : La conception native du cloud fonctionne de manière transparente avec Kubernetes pour la gestion et la mise à l'échelle des applications d'IA
Optimisations spécifiques au matériel : Tire pleinement parti des GPU NVIDIA pour des performances maximales
Flexibilité du framework : Prend en charge plusieurs frameworks d'IA, notamment TensorFlow, PyTorch, ONNX et TensorRT
Open source et personnalisable : Peut être modifié pour répondre à des besoins spécifiques, assurant une flexibilité pour diverses applications d'IA

Prérequis

Assurez-vous d'avoir les prérequis suivants avant de continuer :

Docker installé sur votre machine
Installer tritonclient:
```
pip install tritonclient[all]
```

Exportation de YOLO11 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. Utilisez le export fonction de la YOLO classe :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.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)

Configuration du référentiel de modèles Triton

Le référentiel de modèles Triton est un emplacement de stockage où Triton peut accéder aux modèles et les charger.

Créer la structure de répertoires nécessaire :

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)

Déplacer le modèle ONNX exporté vers le répertoire 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()

data = """
# Add metadata
parameters {
  key: "metadata"
  value {
    string_value: "%s"
  }
}

# (Optional) Enable TensorRT for GPU inference
# 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)

Exécution du serveur d'inférence Triton

Exécutez 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:24.09-py3"  # 8.57 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 --runtime=nvidia --gpus 0 -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)

Ensuite, exécutez l'inférence à l'aide du modèle Triton Server:

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")

Nettoyer le conteneur :

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)

Optimisation TensorRT (facultatif)

Pour des performances encore supérieures, vous pouvez utiliser TensorRT avec Triton Inference Server. TensorRT est un optimiseur d'apprentissage profond haute performance spécialement conçu 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 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 de précision réduite (INT8, FP16) tout en conservant la précision
Fusion de couches pour réduire la surcharge de calcul

Pour utiliser TensorRT directement, vous pouvez exporter votre modèle YOLO11 au format TensorRT :

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo11n.engine'

Pour plus d'informations sur l'optimisation de TensorRT, consultez le guide d'intégration de TensorRT.

En suivant les étapes ci-dessus, vous pouvez déployer et exécuter efficacement les modèles Ultralytics YOLO11 sur le serveur d'inférence Triton, offrant ainsi une solution évolutive et performante pour les tâches d'inférence d'apprentissage profond. Si vous rencontrez des problèmes ou avez d'autres questions, consultez la documentation officielle de Triton ou contactez la communauté Ultralytics pour obtenir de l'aide.

FAQ

Comment configurer Ultralytics YOLO11 avec NVIDIA Triton Inference Server ?

La configuration de Ultralytics YOLO11 avec NVIDIA Triton Inference Server implique quelques étapes clés :

Exporter YOLO11 au format ONNX :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model

# Export the model to ONNX format
onnx_file = model.export(format="onnx", dynamic=True)

Configurer 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écuter 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:24.09-py3"

subprocess.call(f"docker pull {tag}", shell=True)

container_id = (
    subprocess.check_output(
        f"docker run -d --rm --runtime=nvidia --gpus 0 -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 vous aider à déployer efficacement des modèles YOLO11 à grande échelle sur Triton Inference Server pour une inférence de modèles d'IA haute performance.

Quels avantages offre l’utilisation d’Ultralytics YOLO11 avec NVIDIA Triton Inference Server ?

L'intégration d'Ultralytics YOLO11 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, 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 assure des opérations d'inférence à haute vitesse, parfait pour les applications en temps réel telles que la détection d'objets.
Ensemble 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 sa gestion des versions 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, ce qui améliore considérablement le débit et réduit la latence.
Déploiement simplifié : Optimisation progressive des flux de travail d'IA sans nécessiter de refontes complètes du système, ce qui facilite la mise à l'échelle efficace.

Pour des instructions détaillées sur la configuration et l'exécution de YOLO11 avec Triton, vous pouvez consulter le guide de configuration.

Pourquoi devrais-je exporter mon modèle YOLO11 au format ONNX avant d'utiliser Triton Inference Server ?

L'utilisation du format ONNX (Open Neural Network Exchange) pour votre modèle Ultralytics YOLO11 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 d'apprentissage profond (tels que PyTorch, TensorFlow), assurant une compatibilité plus large.
Optimisation : De nombreux environnements de déploiement, y compris 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 dans divers systèmes d'exploitation et configurations matérielles.
Indépendance vis-à-vis du framework : Une fois converti en ONNX, votre modèle n'est plus lié à son framework d'origine, ce qui le rend plus portable.
Normalisation : ONNX fournit une représentation normalisée qui aide à surmonter les problèmes de compatibilité entre les différents frameworks d’IA.

Pour exporter votre modèle, utilisez :

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
onnx_file = model.export(format="onnx", dynamic=True)

Vous pouvez suivre les étapes du guide d'intégration ONNX pour terminer le processus.

Puis-je exécuter l'inférence en utilisant le modèle Ultralytics YOLO11 sur le serveur d'inférence Triton ?

Oui, vous pouvez exécuter l'inférence en utilisant le modèle Ultralytics YOLO11 sur NVIDIA Triton Inference Server. Une fois que votre modèle est configuré dans le référentiel de modèles Triton et que le serveur est en cours d'exécution, vous pouvez charger et exécuter l'inférence sur votre 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")

Cette approche vous permet de tirer parti des optimisations de Triton tout en utilisant l'interface familière d'Ultralytics YOLO. Pour un guide détaillé sur la configuration et l'exécution de Triton Server avec YOLO11, consultez la section exécution du serveur d'inférence Triton.

Comment Ultralytics YOLO11 se compare-t-il aux modèles TensorFlow et PyTorch pour le déploiement ?

Ultralytics YOLO11 offre plusieurs avantages uniques par rapport aux modèles TensorFlow et PyTorch pour le déploiement :

Performance en temps réel : Optimisé pour les tâches de détection d'objets en temps réel, YOLO11 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 : YOLO11 s'intègre de manière transparente à 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 : YOLO11 comprend des fonctionnalités telles que le chargement dynamique de modèles, le contrôle de version des modèles et l’inférence d’ensemble, qui sont essentielles pour les 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, ce qui réduit la courbe d'apprentissage et le temps de développement.
Optimisation Edge : Les modèles YOLO11 sont conçus pour un déploiement Edge, offrant d’excellentes performances, même sur les dispositifs aux ressources limitées.

Pour plus de détails, comparez les options de déploiement dans le guide d'exportation de modèles.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 8 jours