Zum Inhalt springen

Triton Inference Server mit Ultralytics YOLO26

Der Triton Server (früher bekannt als TensorRT Server) ist eine von NVIDIA entwickelte Open-Source-Softwarelösung. Er bietet eine für NVIDIA optimierte Cloud-Inferenzlösung. Triton die Bereitstellung von KI-Modellen in großem Maßstab in der Produktion. Durch die Integration Ultralytics in Triton Server können Sie skalierbare, leistungsstarke Deep-Learning-Inferenz-Workloads bereitstellen. Dieser Leitfaden enthält Anweisungen zur Einrichtung und zum Testen der Integration.



Ansehen: Erste Schritte mit dem NVIDIA Triton Inference Server.

Was ist der Triton Inference Server?

Triton Server wurde entwickelt, um eine Vielzahl von KI-Modellen in der Produktion einzusetzen. Er unterstützt eine breite Palette von 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
  • Dynamisches Laden und Entladen von Modellen ohne Neustart des Servers
  • Ensemble-Inferenz, die es ermöglicht, mehrere Modelle zusammen zu verwenden, um Ergebnisse zu erzielen
  • Modellversionierung für A/B-Tests und fortlaufende Updates

Hauptvorteile von Triton Inference Server

Die Verwendung des Triton Servers mit Ultralytics bietet mehrere Vorteile:

  • Automatische Stapelverarbeitung: Gruppiert mehrere KI-Anfragen vor der Verarbeitung, wodurch die Latenz reduziert und die Inferenzgeschwindigkeit verbessert wird.
  • Kubernetes-Integration: Cloud-natives Design, das nahtlos mit Kubernetes für die Verwaltung und Skalierung von KI-Anwendungen zusammenarbeitet
  • Hardware-spezifische Optimierungen: Nutzt NVIDIA GPUs voll aus, um maximale Leistung zu erzielen.
  • Flexibilität bei den Frameworks: Unterstützt mehrere KI-Frameworks, darunter PyTorch, TensorFlow, ONNX, OpenVINO und TensorRT
  • Open-Source und anpassbar: Kann an spezifische Bedürfnisse angepasst werden, wodurch Flexibilität für verschiedene KI-Anwendungen gewährleistet wird.

Voraussetzungen

Stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen, bevor Sie fortfahren:

  • Docker oder Podman ist auf Ihrem Rechner installiert
  • Installieren ultralytics: 
    pip install ultralytics
  • Installieren tritonclient: 
    pip install tritonclient[all]

Einrichten des Triton -Servers

Führen Sie diesen gesamten Setup-Block aus, um Ultralytics zu exportieren nach ONNX, erstellen Sie das Triton -Repository und starten Sie den Triton Server:

Hinweis

Verwenden Sie den runtime Schalten Sie im Skript um, um Ihre Container-Engine auszuwählen:

  • Set runtime = "docker" für Docker
  • Set 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"
  }
}

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

Inferenz ausführen

Führen Sie eine Inferenz mit dem Triton Modell durch:

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

Den Container reinigen (runtime und container_name (sind im obigen Setup-Block definiert):

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)

TensorRT-Optimierung (Optional)

Für eine noch höhere Leistung können Sie TensorRT mit Triton Inference Server verwenden. TensorRT ist ein hochleistungsfähiger Deep-Learning-Optimierer, der speziell für NVIDIA-GPUs entwickelt wurde und die Inferenzgeschwindigkeit deutlich erhöhen kann.

Die wichtigsten Vorteile der Verwendung von TensorRT mit Triton unter anderem:

  • Bis zu 36x schnellere Inferenz im Vergleich zu nicht optimierten Modellen
  • Hardwarespezifische Optimierungen für maximale GPU-Auslastung
  • Unterstützung für Formate mit reduzierter Präzision (INT8, FP16) bei gleichzeitiger Wahrung der Genauigkeit
  • Layer-Fusion zur Reduzierung des Rechenaufwands

Um TensorRT zu nutzen, können Sie Ihr Ultralytics -Modell in TensorRT 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 finden Sie im TensorRT-Integrationsleitfaden.

Wenn Sie die oben genannten Schritte befolgen, können Sie Ultralytics effizient auf Triton Server bereitstellen und ausführen und erhalten so eine skalierbare und leistungsstarke Lösung für Deep-Learning-Inferenzaufgaben. Sollten Probleme auftreten oder weitere Fragen bestehen, lesen Sie bitte die offizielle Triton oder wenden Sie sich an die Ultralytics , um Unterstützung zu erhalten.

FAQ

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

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

  2. Triton Model Repository einrichten:

    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. Triton Server ausführen:

    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)

Mit dieser Konfiguration können Sie Ultralytics effizient und in großem Maßstab auf Triton Server bereitstellen, um eine leistungsstarke Inferenz von KI-Modellen zu erzielen.

Welche Vorteile bietet die Verwendung von Ultralytics YOLO26 mit dem NVIDIA Triton Inference Server?

Die Integration von Ultralytics in denNVIDIA Triton Server bietet mehrere Vorteile:

  • Skalierbare KI-Inferenz: Triton ermöglicht das Serving mehrerer Modelle von einer einzigen Serverinstanz aus und unterstützt das dynamische Laden und Entladen von Modellen, wodurch es für vielfältige KI-Workloads hochgradig skalierbar ist.
  • Hohe Leistung: Der Triton Inference Server ist für NVIDIA GPUs optimiert und gewährleistet High-Speed-Inferenzoperationen, ideal für Echtzeitanwendungen wie die Objekterkennung.
  • Ensemble und Modellversionierung: Der Ensemble-Modus von Triton ermöglicht die Kombination mehrerer Modelle zur Verbesserung der Ergebnisse, und seine Modellversionierung unterstützt A/B-Tests und fortlaufende Updates.
  • Automatische Stapelverarbeitung: Triton gruppiert automatisch mehrere Inferenzanfragen, wodurch der Durchsatz erheblich verbessert und die Latenz reduziert wird.
  • Vereinfachte Bereitstellung: Allmähliche Optimierung von KI-Workflows, ohne dass eine vollständige Systemüberholung erforderlich ist, was eine effizientere Skalierung ermöglicht.

Ausführliche Anweisungen zur Einrichtung und zum Betrieb Ultralytics mit Triton finden Sie unter „Einrichten des Triton servers und Ausführen der Inferenz“.

Warum sollte ich mein YOLO26-Modell vor der Verwendung des Triton Inference Servers in das ONNX-Format exportieren?

Die Verwendung ONNX -Formats ONNX Open Neural Network Exchange) für Ihr Ultralytics vor der Bereitstellung auf demNVIDIA Triton 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 Deployment-Umgebungen, einschließlich Triton, sind für ONNX optimiert, was schnellere Inferenz und 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: Nach der Konvertierung in ONNX ist Ihr Modell nicht mehr an sein ursprüngliches Framework gebunden, was es portabler macht.
  • Standardisierung: ONNX bietet eine standardisierte Darstellung, die hilft, Kompatibilitätsprobleme zwischen verschiedenen KI-Frameworks zu überwinden.

Um Ihr Modell zu exportieren, verwenden Sie:

from ultralytics import YOLO

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

Sie können die Schritte im ONNX-Integrationsleitfaden befolgen, um den Vorgang abzuschließen.

Kann ich Inferenzen mit dem Ultralytics YOLO26 Modell auf dem Triton Inference Server durchführen?

Ja, Sie können Inferenzberechnungen mit dem Ultralytics auf NVIDIA Triton Server durchführen. Sobald Ihr Modell im Triton Repository eingerichtet ist und der Server läuft, können Sie Ihr Modell wie folgt laden und Inferenzberechnungen darauf 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")

Mit diesem Ansatz können Sie die Optimierungen Triton nutzen und gleichzeitig die vertrauteYOLO Ultralytics verwenden.

Wie verhält sich Ultralytics YOLO26 im Vergleich zu TensorFlow- und PyTorch-Modellen bei der Bereitstellung?

Ultralytics YOLO26 bietet mehrere einzigartige Vorteile im Vergleich zu TensorFlow- und PyTorch-Modellen für die Bereitstellung:

  • Echtzeitleistung: Ultralytics ist für Aufgaben der Objekterkennung in Echtzeit optimiert und bietet höchste Genauigkeit und Geschwindigkeit – damit eignet es sich ideal für Anwendungen, die eine Live-Videoanalyse erfordern.
  • Benutzerfreundlichkeit: Ultralytics lässt sich nahtlos in Triton Server integrieren und unterstützt verschiedene Exportformate (ONNX, TensorRT) und ist somit flexibel für verschiedene Einsatzszenarien einsetzbar.
  • Erweiterte Funktionen: Ultralytics bietet Funktionen wie dynamisches Laden von Modellen, Modellversionierung und Ensemble-Inferenz, die für skalierbare und zuverlässige KI-Implementierungen von entscheidender Bedeutung sind.
  • Vereinfachte API: Die Ultralytics-API bietet eine konsistente Schnittstelle für verschiedene Bereitstellungsziele, wodurch die Lernkurve und die Entwicklungszeit reduziert werden.
  • Edge-Optimierung: Ultralytics Modelle Ultralytics wurden speziell für den Einsatz am Netzwerkrand entwickelt und bieten selbst auf Geräten mit begrenzten Ressourcen eine hervorragende Leistung.

Weitere Details finden Sie im Leitfaden zum Model Export, in dem die Bereitstellungsoptionen verglichen werden.



📅 Erstellt vor 2 Jahren ✏️ Aktualisiert vor 5 Tagen
glenn-jocherY-T-GonuralpszrUltralyticsAssistantleonnil

Kommentare