Triton Inferenz-Server mit Ultralytics YOLOv8

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

Die Einrichtung von Ultralytics YOLOv8 mit NVIDIA Triton Inference Server erfordert ein paar wichtige Schritte: Mit diesem Setup kannst du YOLOv8 Modelle effizient und in großem Umfang auf Triton Inference Server für leistungsstarke KI-Modellinferenz einsetzen.

Q: Can I run inference using the Ultralytics YOLOv8 model on Triton Inference Server?

Ja, du kannst mit dem Modell Ultralytics YOLOv8 auf dem Inference Server NVIDIA Triton Inferenzen durchführen. Sobald dein Modell im Triton Modell-Repository eingerichtet ist und der Server läuft, kannst du dein Modell wie folgt laden und mit ihm Inferenzen durchführen: Eine ausführliche Anleitung zum Einrichten und Ausführen von Triton Server mit YOLOv8 findest du im Abschnitt triton Inference Server ausführen.

Q: How does Ultralytics YOLOv8 compare to TensorFlow and PyTorch models for deployment?

Ultralytics YOLOv8 bietet im Vergleich zu den Modellen TensorFlow und PyTorch mehrere einzigartige Vorteile für den Einsatz: Für weitere Details vergleiche die Einsatzoptionen im Leitfaden zum Modelleinsatz.

Der Triton Inference Server (früher bekannt als 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 den Einsatz von KI-Modellen in großem Maßstab in der Produktion. Durch die Integration von Ultralytics YOLOv8 mit Triton Inference Server kannst du skalierbare, hochleistungsfähige Deep Learning Inference Workloads einsetzen. Dieser Leitfaden beschreibt die Schritte zum Einrichten und Testen der Integration.

Pass auf: Erste Schritte mit NVIDIA Triton Inference Server.

Was ist Triton Inference Server?

Triton Der Inference 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 TensorFlow, PyTorch, ONNX Runtime und viele andere. Seine wichtigsten Anwendungsfälle sind:

Mehrere Modelle von einer einzigen Serverinstanz aus bedienen.
Dynamisches Laden und Entladen von Modellen ohne Server-Neustart.
Ensemble-Inferenz, bei der mehrere Modelle zusammen verwendet werden können, um Ergebnisse zu erzielen.
Modellversionierung für A/B-Tests und rollierende Updates.

Voraussetzungen

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

Docker ist auf deinem Rechner installiert.
Installiere tritonclient:
```
pip install tritonclient[all]
```

Exportieren von YOLOv8 in das Format ONNX

Bevor das Modell auf Triton eingesetzt werden kann, muss es in das Format ONNX exportiert werden. ONNX (Open Neural Network Exchange) ist ein Format, mit dem Modelle zwischen verschiedenen Deep-Learning-Frameworks übertragen werden können. Verwende das export Funktion aus der YOLO Klasse:

from ultralytics import YOLO

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

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

Einrichten von Triton Model Repository

Das Triton Model Repository ist ein Speicherort, an dem Triton Modelle abrufen und laden kann.

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

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

Triton Inference Server ausführen

Führe 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:23.09-py3"  # 6.4 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 -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ühre dann die Inferenz mit dem Triton Server-Modell durch:

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

Reinige den Container:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)

Wenn du die oben genannten Schritte befolgst, kannst du Ultralytics YOLOv8 Modelle effizient auf dem Triton Inference Server einsetzen und ausführen und so eine skalierbare und leistungsstarke Lösung für Deep Learning Inferenzaufgaben bereitstellen. Solltest du auf Probleme stoßen oder weitere Fragen haben, kannst du in der offiziellen Triton Dokumentation nachschlagen oder dich an die Ultralytics Community wenden, um Unterstützung zu erhalten.

FAQ

Wie richte ich Ultralytics YOLOv8 mit NVIDIA Triton Inference Server ein?

Das Einrichten Ultralytics YOLOv8 mit NVIDIA Triton Inference Server umfasst ein paar wichtige Schritte:

Exportiere YOLOv8 in das Format ONNX :

from ultralytics import YOLO

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

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

Richte das Triton Model 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()

Führe den Triton Server 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:23.09-py3"

subprocess.call(f"docker pull {tag}", shell=True)

container_id = (
    subprocess.check_output(
        f"docker run -d --rm -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)

Mit diesem Setup kannst du YOLOv8 Modelle auf Triton Inference Server für hochleistungsfähige KI-Modellinferenz effizient einsetzen.

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

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

Skalierbare KI-Inferenz: Triton ermöglicht es, mehrere Modelle von einer einzigen Serverinstanz aus zu bedienen und unterstützt das dynamische Laden und Entladen von Modellen, was es für verschiedene KI-Workloads hoch skalierbar macht.
Hohe Leistung: Der Triton Inference Server wurde für NVIDIA GPUs optimiert und gewährleistet schnelle Inferenzoperationen, die sich perfekt für Echtzeitanwendungen wie die Objekterkennung eignen.
Ensemble und Modellversionierung: Der Ensemble-Modus von Triton ermöglicht die Kombination mehrerer Modelle, um die Ergebnisse zu verbessern, und die Modellversionierung unterstützt A/B-Tests und rollierende Updates.

Ausführliche Anweisungen zum Einrichten und Ausführen von YOLOv8 mit Triton findest du in der Einrichtungsanleitung.

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

Die Verwendung des Formats ONNX (Open Neural Network Exchange) für dein Ultralytics YOLOv8 (Open Neural Network Exchange) für dein Modell, bevor du es auf NVIDIA Triton Inference Server bereitstellst, bietet mehrere wichtige Vorteile:

Interoperabilität: Das Format ONNX unterstützt den Transfer zwischen verschiedenen Deep-Learning-Frameworks (z. B. PyTorch, TensorFlow) und gewährleistet so eine breitere Kompatibilität.
Optimierung: Viele Einsatzumgebungen, darunter Triton, optimieren für ONNX und ermöglichen so schnellere Schlussfolgerungen und eine bessere Leistung.
Einfacher Einsatz: ONNX wird von vielen Frameworks und Plattformen unterstützt, was den Einsatz auf verschiedenen Betriebssystemen und Hardwarekonfigurationen vereinfacht.

Um dein Modell zu exportieren, verwende:

from ultralytics import YOLO

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

Du kannst die Schritte in der Exportanleitung befolgen, um den Prozess abzuschließen.

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

Ja, du kannst die Inferenz mit dem Ultralytics YOLOv8 Modell auf 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 mit Inferenz arbeiten:

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

Eine ausführliche Anleitung zum Einrichten und Betreiben von Triton Server mit YOLOv8 findest du im Abschnitt triton Inferenzserver betreiben.

Wie unterscheidet sich Ultralytics YOLOv8 von den Modellen TensorFlow und PyTorch für den Einsatz?

Ultralytics YOLOv8 bietet mehrere einzigartige Vorteile im Vergleich zu TensorFlow und PyTorch Modellen für den Einsatz:

Leistung in Echtzeit: Optimiert für Echtzeit-Objekterkennungsaufgaben bietet YOLOv8 modernste Genauigkeit und Geschwindigkeit und ist damit ideal für Anwendungen, die eine Live-Videoanalyse erfordern.
Benutzerfreundlichkeit: YOLOv8 lässt sich nahtlos in den Triton Inference Server integrieren und unterstützt verschiedene Exportformate (ONNX, TensorRT, CoreML), was es flexibel für verschiedene Einsatzszenarien macht.
Erweiterte Funktionen: YOLOv8 enthält Funktionen wie dynamisches Laden von Modellen, Modellversionierung und Ensemble-Inferenz, die für skalierbare und zuverlässige KI-Einsätze entscheidend sind.

Für weitere Details vergleiche die Bereitstellungsoptionen im Leitfaden zur Modellbereitstellung.

Erstellt am 2023-11-12, Aktualisiert am 2024-07-05
Autoren: glenn-jocher (10)