Link to this sectionTriton 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 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. Intégrer Ultralytics YOLO26 au Triton Inference Server te permet de déployer des charges de travail d'inférence deep learning évolutives et performantes. Ce guide fournit les étapes pour configurer et tester l'intégration.

Watch: Getting Started with NVIDIA Triton Inference Server.

Link to this sectionQu'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, incluant 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

Link to this sectionAvantages clés de Triton Inference Server#

L'utilisation de Triton Inference Server avec Ultralytics YOLO26 offre 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

Link to this sectionPrérequis#

Assure-toi d'avoir les prérequis suivants avant de continuer :

Docker ou Podman installés sur ta machine
Installe ultralytics :
```
pip install ultralytics
```
Installe tritonclient :
```
pip install tritonclient[all]
```

Link to this sectionConfiguration 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 :

Remarque

Utilise l'option runtime dans le script pour choisir ton moteur de conteneur :

Définit runtime = "docker" pour Docker
Définit 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)

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus 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)

Link to this sectionExé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)

Link to this sectionOptimisation TensorRT (Optionnel)#

Pour des performances encore plus élevées, tu peux utiliser TensorRT avec Triton Inference Server. TensorRT est un optimiseur de deep learning haute performance conçu spécifiquement pour les GPU NVIDIA, qui peut considérablement augmenter la vitesse d'inférence.

Les avantages clés 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 TensorRT directement, 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 maintenant 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.

Link to this sectionFAQ#

Link to this sectionComment configurer Ultralytics YOLO26 avec NVIDIA Triton Inference Server ?#

La configuration d'Ultralytics YOLO26 avec NVIDIA Triton Inference Server implique quelques étapes clés :

Exporter YOLO26 au format ONNX :

from ultralytics import YOLO

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

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

Configurer le dépôt 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:26.02-py3"

runtime = "docker"  # set to "podman" to use Podman
subprocess.call(f"{runtime} pull {tag}", shell=True)

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus all"

container_name = "triton_server"
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,
)

triton_client = InferenceServerClient(url="127.0.0.1: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 des modèles Ultralytics YOLO26 à grande échelle sur Triton Inference Server pour une inférence de modèles d'IA haute performance.

Link to this sectionQuels avantages l'utilisation d'Ultralytics YOLO26 avec NVIDIA Triton Inference Server offre-t-elle ?#

Intégrer 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, parfait 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 de Ultralytics YOLO26 avec Triton, consulte Setting Up Triton Inference Server et Running Inference.

Link to this sectionPourquoi devrais-je exporter mon modèle YOLO26 au format ONNX avant d'utiliser Triton Inference Server ?#

Utiliser le 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 terminer le processus.

Link to this sectionPuis-je exécuter une inférence en utilisant le modèle Ultralytics YOLO26 sur Triton Inference Server ?#

Oui, tu peux exécuter une inférence en utilisant le 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 et exécuter l'inférence sur ton modèle comme suit :

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.

Link to this sectionComment Ultralytics YOLO26 se compare-t-il aux modèles TensorFlow et PyTorch pour le déploiement ?#

Ultralytics YOLO26 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, Ultralytics YOLO26 offre une précision et une vitesse de pointe, le rendant idéal pour les applications nécessitant des analyses vidéo en direct.
Facilité d'utilisation : Ultralytics YOLO26 s'intègre parfaitement à Triton Inference Server et prend en charge divers formats d'exportation (ONNX, TensorRT), le rendant flexible pour divers 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 d'ensemble, qui sont cruciales 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 l'Edge : Les modèles Ultralytics YOLO26 sont conçus en pensant au déploiement en périphérie (Edge), 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 de modèles.

Contributeurs

GLglenn-jocher¹⁸ Y-Y-T-G⁴ RAraimbekovm² ONonuralpszr² LEleonnil¹

Créé 12 nov. 2023Mis à jour il y a 4 jours