Triton Inference Server mit Ultralytics YOLO11

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

Das Einrichten von Ultralytics YOLO11 mit dem NVIDIA Triton Inference Server umfasst einige wichtige Schritte: Dieses Setup kann Ihnen helfen, YOLO11-Modelle effizient und in großem Maßstab auf dem Triton Inference Server für hochleistungsfähige KI-Modellinferenzen bereitzustellen.

Der Triton Inference Server (ehemals TensorRT Inference Server) ist eine von NVIDIA entwickelte Open-Source-Softwarelösung. 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. Die Integration von Ultralytics YOLO11 mit dem Triton Inference Server ermöglicht Ihnen die Bereitstellung von skalierbaren, hochleistungsfähigen Deep-Learning-Inferenz-Workloads. Dieser Leitfaden enthält Schritte zum Einrichten und Testen der Integration.

Ansehen: Erste Schritte mit dem NVIDIA Triton Inference Server.

Was ist der Triton Inference Server?

Der Triton Inference Server wurde entwickelt, um eine Vielzahl von KI-Modellen in der Produktion bereitzustellen. Er unterstützt eine breite Palette von Deep-Learning- und Machine-Learning-Frameworks, darunter TensorFlow, PyTorch, ONNX Runtime und viele andere. Seine Hauptanwendungsfä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 von Triton Inference Server mit Ultralytics YOLO11 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.
Framework-Flexibilität: Unterstützt mehrere KI-Frameworks, darunter TensorFlow, PyTorch, ONNX 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 ist auf Ihrem Rechner installiert
Installieren tritonclient:
```
pip install tritonclient[all]
```

YOLO11 in das ONNX-Format exportieren

Bevor das Modell auf Triton bereitgestellt werden kann, muss es in das ONNX-Format exportiert werden. ONNX (Open Neural Network Exchange) ist ein Format, das den Transfer von Modellen zwischen verschiedenen Deep-Learning-Frameworks ermöglicht. Verwenden Sie die export Funktion aus dem YOLO Klasse zusammenfasst:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.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)

Einrichten des Triton Model Repository

Das Triton Model Repository ist ein Speicherort, auf den Triton zugreifen und Modelle laden kann.

Erstellen Sie die notwendige Verzeichnisstruktur:

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)

Verschieben Sie das exportierte ONNX-Modell in das Triton-Repository:

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

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)

Ausführen des Triton Inference Servers

Führen Sie den Triton Inference Server mit Docker aus:

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)

Führen Sie dann die Inferenz mit dem Triton Server-Modell aus:

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

Bereinigen Sie den Container:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", 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.

Zu den wichtigsten Vorteilen der Verwendung von TensorRT mit Triton gehören:

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 direkt zu verwenden, können Sie Ihr YOLO11-Modell in das TensorRT-Format exportieren:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo11n.engine'

Weitere Informationen zur TensorRT-Optimierung finden Sie im TensorRT-Integrationsleitfaden.

Durch das Befolgen der obigen Schritte können Sie Ultralytics YOLO11-Modelle effizient auf dem Triton Inference Server bereitstellen und ausführen und so eine skalierbare und leistungsstarke Lösung für Deep-Learning-Inferenzaufgaben bereitstellen. Wenn Sie auf Probleme stoßen oder weitere Fragen haben, lesen Sie die offizielle Triton-Dokumentation oder wenden Sie sich an die Ultralytics-Community, um Unterstützung zu erhalten.

FAQ

Wie richte ich Ultralytics YOLO11 mit dem NVIDIA Triton Inference Server ein?

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

YOLO11 in das ONNX-Format exportieren:

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)

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

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

Dieses Setup kann Ihnen helfen, YOLO11-Modelle effizient und in großem Maßstab auf dem Triton Inference Server für hochleistungsfähige KI-Modellinferenzen bereitzustellen.

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

Die Integration von Ultralytics YOLO11 mit dem NVIDIA Triton Inference 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.

Für detaillierte Anweisungen zur Einrichtung und Ausführung von YOLO11 mit Triton können Sie die Einrichtungsanleitung konsultieren.

Warum sollte ich mein YOLO11-Modell in das ONNX-Format exportieren, bevor ich den Triton Inference Server verwende?

Die Verwendung des ONNX-Formats (Open Neural Network Exchange) für Ihr Ultralytics YOLO11-Modell vor der Bereitstellung auf dem NVIDIA Triton Inference Server bietet mehrere wichtige 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("yolo11n.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 Inferenz mit dem Ultralytics YOLO11-Modell auf dem Triton Inference Server ausführen?

Ja, Sie können die Inferenz mit dem Ultralytics YOLO11-Modell auf dem NVIDIA Triton Inference Server ausführen. Sobald Ihr Modell im Triton Model Repository eingerichtet ist und der Server läuft, können Sie Ihr Modell wie folgt laden und die Inferenz ausführen:

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

Dieser Ansatz ermöglicht es Ihnen, die Optimierungen von Triton zu nutzen und gleichzeitig die vertraute Ultralytics YOLO-Schnittstelle zu verwenden. Eine ausführliche Anleitung zum Einrichten und Ausführen von Triton Server mit YOLO11 finden Sie im Abschnitt Running Triton Inference Server.

Wie schneidet Ultralytics YOLO11 im Vergleich zu TensorFlow- und PyTorch-Modellen für die Bereitstellung ab?

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

Echtzeit-Performance: YOLO11 ist für Echtzeit-Objekterkennungsaufgaben optimiert und bietet modernste Genauigkeit und Geschwindigkeit, wodurch es ideal für Anwendungen ist, die Live-Videoanalysen erfordern.
Benutzerfreundlichkeit: YOLO11 lässt sich nahtlos in den Triton Inference Server integrieren und unterstützt verschiedene Exportformate (ONNX, TensorRT, CoreML), wodurch es flexibel für verschiedene Bereitstellungsszenarien ist.
Erweiterte Funktionen: YOLO11 umfasst Funktionen wie dynamisches Modellladen, Modellversionierung 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, wodurch die Lernkurve und die Entwicklungszeit reduziert werden.
Edge-Optimierung: YOLO11-Modelle sind auf die Edge-Bereitstellung ausgelegt und bieten selbst auf ressourcenbeschränkten Geräten eine hervorragende Leistung.

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

📅 Vor 1 Jahr erstellt ✏️ Vor 5 Monaten aktualisiert