Link to this sectionTriton Inference Server mit Ultralytics YOLO26#

Der Triton Inference Server (früher bekannt als TensorRT Inference Server) ist eine Open-Source-Softwarelösung von NVIDIA. Er bietet eine Cloud-Inferenzlösung, die für NVIDIA GPUs optimiert ist. Triton vereinfacht die Bereitstellung von KI-Modellen in großem Maßstab in der Produktion. Durch die Integration von Ultralytics YOLO26 mit dem Triton Inference Server kannst du skalierbare, hochleistungsfähige Deep Learning-Inferenz-Workloads bereitstellen. Dieser Leitfaden enthält die Schritte zur Einrichtung und zum Testen der Integration.

Watch: Getting Started with NVIDIA Triton Inference Server.

Link to this sectionWas ist der Triton Inference Server?#

Der Triton Inference Server ist für die Bereitstellung einer Vielzahl von KI-Modellen in der Produktion konzipiert. Er unterstützt eine breite Palette an Deep Learning- und Machine Learning-Frameworks, darunter PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT und viele andere. Die wichtigsten Anwendungsfälle sind:

Bereitstellung mehrerer Modelle von einer einzigen Serverinstanz aus
Dynamisches Laden und Entladen von Modellen ohne Server-Neustart
Ensemble-Inferenz, die es ermöglicht, mehrere Modelle gemeinsam zu verwenden, um Ergebnisse zu erzielen
Modell-Versionierung für A/B-Tests und Rolling Updates

Link to this sectionWichtige Vorteile des Triton Inference Server#

Die Verwendung des Triton Inference Server mit Ultralytics YOLO26 bietet mehrere Vorteile:

Automatisches Batching: Gruppiert mehrere KI-Anfragen vor der Verarbeitung, um die Latenz zu verringern und die Inferenzgeschwindigkeit zu verbessern
Kubernetes-Integration: Das Cloud-native Design arbeitet nahtlos mit Kubernetes zusammen, um KI-Anwendungen zu verwalten und zu skalieren
Hardware-spezifische Optimierungen: Nutzt NVIDIA GPUs vollständig aus, um maximale Leistung zu erzielen
Framework-Flexibilität: Unterstützt mehrere KI-Frameworks, einschließlich PyTorch, TensorFlow, ONNX, OpenVINO und TensorRT
Open-Source und anpassbar: Kann an spezifische Anforderungen angepasst werden, was Flexibilität für verschiedene KI-Anwendungen gewährleistet

Link to this sectionVoraussetzungen#

Stelle sicher, dass du die folgenden Voraussetzungen erfüllst, bevor du fortfährst:

Docker oder Podman auf deinem System installiert
Installiere ultralytics:
```
pip install ultralytics
```
Installiere tritonclient:
```
pip install tritonclient[all]
```

Link to this sectionEinrichten des Triton Inference Server#

Führe diesen vollständigen Setup-Block aus, um Ultralytics YOLO26 nach ONNX zu exportieren, das Triton-Modell-Repository zu erstellen und den Triton Inference Server zu starten:

Hinweis

Verwende den runtime-Schalter im Skript, um deine Container-Engine auszuwählen:

Setze runtime = "docker" für Docker
Setze runtime = "podman" für 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 sectionAusführen der Inferenz#

Führe die Inferenz unter Verwendung des Triton Server-Modells aus:

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

Bereinige den Container:

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 sectionTensorRT-Optimierung (Optional)#

Für eine noch höhere Leistung kannst du TensorRT mit dem Triton Inference Server verwenden. TensorRT ist ein leistungsstarker Deep-Learning-Optimierer, der speziell für NVIDIA GPUs entwickelt wurde und die Inferenzgeschwindigkeit erheblich steigern kann.

Die Hauptvorteile der Verwendung von TensorRT mit Triton sind:

Bis zu 36-mal schnellere Inferenz im Vergleich zu nicht optimierten Modellen
Hardware-spezifische Optimierungen für eine maximale GPU-Auslastung
Unterstützung für Formate mit reduzierter Präzision (INT8, FP16) bei gleichbleibender Genauigkeit
Layer-Fusion zur Reduzierung des Rechenaufwands

Um TensorRT direkt zu verwenden, kannst du dein Ultralytics YOLO26-Modell in das TensorRT-Format exportieren:

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'

Weitere Informationen zur TensorRT-Optimierung findest du im TensorRT-Integrationsleitfaden.

Du kannst jetzt Ultralytics YOLO26-Modelle auf dem Triton Inference Server für skalierbare High-Performance-Inferenz bereitstellen und ausführen. Weitere Details findest du in der offiziellen Triton-Dokumentation oder frage die Ultralytics-Community um Hilfe.

Link to this sectionFAQ#

Link to this sectionWie richte ich Ultralytics YOLO26 mit dem NVIDIA Triton Inference Server ein?#

Die Einrichtung von Ultralytics YOLO26 mit dem NVIDIA Triton Inference Server umfasst einige wichtige Schritte:

Exportiere YOLO26 in das ONNX-Format:

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)

Richte das Triton-Modell-Repository ein:

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

Starte den Triton-Server:

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)

Dieses Setup hilft dir dabei, Ultralytics YOLO26-Modelle effizient und skaliert auf dem Triton Inference Server für eine leistungsstarke KI-Modell-Inferenz bereitzustellen.

Link to this sectionWelche Vorteile bietet die Verwendung von Ultralytics YOLO26 mit dem NVIDIA Triton Inference Server?#

Die Integration von Ultralytics YOLO26 mit dem NVIDIA Triton Inference Server bietet mehrere Vorteile:

Skalierbare KI-Inferenz: Triton ermöglicht die Bereitstellung mehrerer Modelle von einer einzigen Serverinstanz aus und unterstützt das dynamische Laden und Entladen von Modellen, was es für verschiedene KI-Workloads hochgradig skalierbar macht.
Hohe Leistung: Der Triton Inference Server ist für NVIDIA GPUs optimiert und gewährleistet Hochgeschwindigkeits-Inferenzvorgänge, die sich perfekt für Echtzeitanwendungen wie Objekterkennung eignen.
Ensemble- und Modell-Versionierung: Der Ensemble-Modus von Triton ermöglicht die Kombination mehrerer Modelle zur Verbesserung der Ergebnisse, und die Modell-Versionierung unterstützt A/B-Tests und Rolling Updates.
Automatisches Batching: Triton gruppiert automatisch mehrere Inferenzanfragen, was den Durchsatz erheblich verbessert und die Latenz verringert.
Vereinfachte Bereitstellung: Schrittweise Optimierung von KI-Workflows ohne die Notwendigkeit vollständiger Systemüberholungen, was eine effiziente Skalierung erleichtert.

Detaillierte Anweisungen zur Einrichtung und Ausführung von Ultralytics YOLO26 mit Triton findest du unter Triton Inference Server einrichten und Inferenz ausführen.

Link to this sectionWarum sollte ich mein YOLO26-Modell vor der Verwendung des Triton Inference Server in das ONNX-Format exportieren?#

Die Verwendung des ONNX-Formats (Open Neural Network Exchange) für dein Ultralytics YOLO26-Modell vor der Bereitstellung auf dem NVIDIA Triton Inference Server bietet mehrere wesentliche Vorteile:

Interoperabilität: Das ONNX-Format unterstützt den Transfer zwischen verschiedenen Deep-Learning-Frameworks (wie PyTorch, TensorFlow) und gewährleistet so eine breitere Kompatibilität.
Optimierung: Viele Bereitstellungsumgebungen, einschließlich Triton, sind auf ONNX optimiert, was eine schnellere Inferenz und eine bessere Leistung ermöglicht.
Einfache Bereitstellung: ONNX wird von vielen Frameworks und Plattformen unterstützt, was den Bereitstellungsprozess in verschiedenen Betriebssystemen und Hardwarekonfigurationen vereinfacht.
Framework-Unabhängigkeit: Sobald dein Modell in ONNX konvertiert wurde, ist es nicht mehr an sein ursprüngliches Framework gebunden, was es portabler macht.
Standardisierung: ONNX bietet eine standardisierte Repräsentation, die hilft, Kompatibilitätsprobleme zwischen verschiedenen KI-Frameworks zu überwinden.

Um dein Modell zu exportieren, verwende:

from ultralytics import YOLO

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

Du kannst den Schritten im ONNX-Integrationsleitfaden folgen, um den Prozess abzuschließen.

Link to this sectionKann ich die Inferenz mit dem Ultralytics YOLO26-Modell auf dem Triton Inference Server ausführen?#

Ja, du kannst die Inferenz mit dem Ultralytics YOLO26-Modell auf dem NVIDIA Triton Inference Server ausführen. Sobald dein Modell im Triton-Modell-Repository eingerichtet ist und der Server läuft, kannst du dein Modell wie folgt laden und die Inferenz ausführen:

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

Dieser Ansatz ermöglicht es dir, die Optimierungen von Triton zu nutzen und gleichzeitig die vertraute Ultralytics YOLO-Schnittstelle beizubehalten.

Link to this sectionWie schneidet Ultralytics YOLO26 im Vergleich zu TensorFlow- und PyTorch-Modellen bei der Bereitstellung ab?#

Ultralytics YOLO26 bietet mehrere einzigartige Vorteile gegenüber TensorFlow- und PyTorch-Modellen für die Bereitstellung:

Echtzeit-Leistung: Optimiert für Echtzeit-Objekterkennungsaufgaben, bietet Ultralytics YOLO26 modernste Genauigkeit und Geschwindigkeit, was es ideal für Anwendungen macht, die Live-Videoanalysen erfordern.
Benutzerfreundlichkeit: Ultralytics YOLO26 lässt sich nahtlos in den Triton Inference Server integrieren und unterstützt verschiedene Exportformate (ONNX, TensorRT), was es flexibel für diverse Bereitstellungsszenarien macht.
Erweiterte Funktionen: Ultralytics YOLO26 umfasst Funktionen wie dynamisches Laden von Modellen, Modell-Versionierung und Ensemble-Inferenz, die für skalierbare und zuverlässige KI-Bereitstellungen entscheidend sind.
Vereinfachte API: Die Ultralytics-API bietet eine konsistente Schnittstelle für verschiedene Bereitstellungsziele, was die Lernkurve verkürzt und die Entwicklungszeit reduziert.
Edge-Optimierung: Ultralytics YOLO26-Modelle sind für die Edge-Bereitstellung konzipiert und bieten selbst auf ressourcenbeschränkten Geräten eine hervorragende Leistung.

Weitere Details findest du beim Vergleich der Bereitstellungsoptionen im Modell-Export-Leitfaden.

Mitwirkende

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

Erstellt 12. Nov. 2023Aktualisiert vor 3 Tagen