Triton Serveur d'inférence avec Ultralytics YOLO11

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

L'installation de Ultralytics YOLO11 avec NVIDIA Triton Inference Server implique quelques étapes clés : 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.

Q: What benefits does using Ultralytics YOLO11 with NVIDIA Triton Inference Server offer?

L'intégration de Ultralytics YOLO11 avec NVIDIA Triton Inference Server offre plusieurs avantages : Pour des instructions détaillées sur l'installation et l'utilisation de YOLO11 avec Triton, vous pouvez vous référer au guide d'installation.

Le serveur d'inférenceTriton (anciennement connu sous le nom de serveur d'inférence TensorRT ) 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 à grande échelle en production. L'intégration de Ultralytics YOLO11 avec Triton Inference Server vous 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.

Regarder : 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 cadres d'apprentissage profond et d'apprentissage automatique, notamment TensorFlow, PyTorchONNX 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 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

Assurez-vous que vous disposez des conditions préalables suivantes avant de poursuivre :

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

Exportation de YOLO11 vers le 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 cadres d'apprentissage profond. Utilisez le format export de la fonction YOLO classe :

from ultralytics import YOLO

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

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

Mise en place du référentiel de modèles Triton

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

Créer la structure de répertoire 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 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()

# (Optional) Enable TensorRT for GPU inference
# First run will be slow due to TensorRT engine conversion
data = """
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"
      }
    }
  }
}
"""

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

Exécutez 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")

Nettoyer le conteneur :

# 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, vous pouvez déployer et exécuter efficacement les modèles Ultralytics YOLO11 sur Triton Inference Server, en fournissant une solution évolutive et performante pour les tâches d'inférence d'apprentissage profond. Si vous rencontrez des problèmes ou si vous avez d'autres questions, reportez-vous à la documentation officielle Triton ou contactez la communauté Ultralytics pour obtenir de l'aide.

FAQ

Comment configurer Ultralytics YOLO11 avec NVIDIA Triton Inference Server ?

La mise en place 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)

Mise en place du 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écutez 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 --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 les modèles YOLO11 à grande échelle sur Triton Inference Server pour une inférence de modèle d'IA haute performance.

Quels sont les avantages de l'utilisation de Ultralytics YOLO11 avec NVIDIA Triton Inference Server ?

L'intégration Ultralytics YOLO11 avec NVIDIA Triton Inference Server présente 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 hautement évolutif pour diverses charges de travail en matière d'IA.
Haute performance: Optimisé pour les GPU NVIDIA , Triton Inference Server garantit 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 afin d'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 des instructions détaillées sur l'installation et l'utilisation de YOLO11 avec Triton, vous pouvez vous référer au guide d'installation.

Pourquoi dois-je exporter mon modèle YOLO11 au format ONNX avant d'utiliser le serveur d'inférence Triton ?

L'utilisation du format ONNX (Open Neural Network Exchange) pour votre modèle avant de le déployer sur Inference Server offre plusieurs avantages. Ultralytics YOLO11 modèle 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 cadres d'apprentissage en profondeur (tels que PyTorch, TensorFlow), garantissant ainsi une plus grande compatibilité.
Optimisation: De nombreux environnements de déploiement, y compris Triton, optimisent 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 plates-formes, ce qui simplifie le processus de déploiement dans divers systèmes d'exploitation et configurations matérielles.

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'exportation pour compléter le processus.

Puis-je effectuer une 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 fonctionne, 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")

Pour un guide détaillé sur l'installation et l'utilisation du serveur Triton avec YOLO11, reportez-vous à la section sur l'utilisation du serveur d'inférence triton .

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

Ultralytics YOLO11 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, 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 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: YOLO11 comprend des fonctionnalités telles que le chargement dynamique de modèles, la gestion des versions 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, comparez les options de déploiement dans le guide de déploiement du modèle.

📅C réé il y a 1 an ✏️ Mis à jour il y a 22 jours