Passer au contenu

Triton Inference Server avec Ultralytics YOLO26

Le Triton Server (anciennement TensorRT Server) est une solution logicielle open source développée par NVIDIA. Il offre une solution d'inférence dans le cloud optimisée pour NVIDIA . Triton le déploiement à grande échelle de modèles d'IA en production. L'intégration Ultralytics au Triton Server vous permet de déployer des charges de travail d'inférence d'apprentissage profond évolutives et hautement performantes. Ce guide présente les étapes à suivre pour configurer et tester cette intégration.



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

Qu'est-ce que Triton Inference Server ?

Triton Server est conçu pour déployer divers modèles d'IA en production. Il prend en charge un large éventail de frameworks d'apprentissage profond et d'apprentissage automatique, notamment PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT 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 Server avec Ultralytics 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é 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, assurant une flexibilité pour diverses applications d'IA

Prérequis

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

  • Docker ou Podman est installé sur votre ordinateur
  • Installer ultralytics: 
    pip install ultralytics
  • Installer tritonclient: 
    pip install tritonclient[all]

Configuration du serveur Triton

Exécutez ce bloc de configuration complet pour exporter Ultralytics vers ONNX, créer le référentiel Triton et démarrer le serveur Triton :

Remarque

Utilisez la runtime Utilisez le paramètre suivant dans le script pour choisir votre moteur de conteneurs :

  • Définir runtime = "docker" pour Docker
  • Définir 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"
  }
}

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

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

Exécution de l'inférence

Exécuter l'inférence à l'aide du modèle Triton :

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

Nettoyer le conteneur (runtime et container_name (sont définies dans le bloc de configuration ci-dessus) :

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)

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.

Principaux avantages de l'utilisation de TensorRT avec Triton les Triton :

  • 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 , vous pouvez exporter votre modèle Ultralytics au 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 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 sur Triton Server, ce qui vous offre une solution évolutive et hautement performante pour les tâches d'inférence en apprentissage profond. Si vous rencontrez des difficultés ou avez d'autres questions, consultez la Triton officielle Triton ou contactez la Ultralytics pour obtenir de l'aide.

FAQ

Comment configurer Ultralytics YOLO26 avec NVIDIA Triton Inference Server ?

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

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

  2. 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()

  3. 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 vous permet de déployer efficacement et à grande échelle les modèles Ultralytics sur Triton Server afin de bénéficier d'une inférence de modèles d'IA hautement performante.

Quels sont les avantages d'utiliser Ultralytics YOLO26 avec NVIDIA Triton Inference Server ?

L'intégration Ultralytics à NVIDIA Triton 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 obtenir des instructions détaillées sur la configuration et l'exécution Ultralytics avec Triton, consultez la section « Configuration du serveur Triton et exécution de l'inférence ».

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

L'utilisation du format ONNX Open Neural Network Exchange) pour votre modèle Ultralytics avant de le déployer sur NVIDIA Triton Server présente plusieurs avantages majeurs :

  • 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("yolo26n.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 YOLO26 sur Triton Inference Server ?

Oui, vous pouvez effectuer une inférence à l'aide du modèle Ultralytics sur le serveurTriton NVIDIA Triton . Une fois votre modèle configuré dans le référentiel Triton et le serveur en cours d'exécution, vous pouvez charger votre modèle et effectuer une inférence 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 vous permet de tirer parti des optimisations Triton tout en utilisantYOLO familière Ultralytics YOLO .

Comment 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 :

  • Performances en temps réel: Optimisé pour les tâches de détection d'objets en temps réel, Ultralytics offre une précision et une vitesse de pointe, ce qui en fait la solution idéale pour les applications nécessitant une analyse vidéo en direct.
  • Facilité d'utilisation: Ultralytics s'intègre parfaitement à Triton Server et prend en charge divers formats d'exportation (ONNX, TensorRT), ce qui le rend flexible pour divers scénarios de déploiement.
  • Fonctionnalités avancées: Ultralytics intègre des fonctionnalités telles que le chargement dynamique des modèles, la gestion des versions des modèles et l'inférence par ensemble, qui sont essentielles pour des 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 en périphérie: les modèles Ultralytics sont conçus pour un déploiement en périphérie et offrent d'excellentes performances, même sur des appareils 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 2 ans ✏️ Mis à jour il y a 6 jours
glenn-jocherY-T-GonuralpszrUltralyticsAssistantleonnil

Commentaires