Triton Inferenz-Server mit Ultralytics YOLO11

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

Die Einrichtung von Ultralytics YOLO11 mit NVIDIA Triton Inference Server umfasst einige wichtige Schritte: Mit dieser Einrichtung können Sie YOLO11 Modelle effizient und in großem Umfang auf Triton Inference Server für hochleistungsfähige KI-Modellinferenz einsetzen.

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 die Bereitstellung von KI-Modellen in großem Maßstab in der Produktion. Durch die Integration von Ultralytics YOLO11 mit Triton Inference Server können Sie skalierbare, leistungsstarke Deep-Learning-Inferenz-Workloads bereitstellen. Dieser Leitfaden enthält Schritte zum Einrichten und Testen der Integration.

Beobachten: Erste Schritte mit NVIDIA Triton Inference Server.

Was ist Triton Inference Server?

Triton 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 primären 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 fortlaufende Aktualisierungen

Die wichtigsten Vorteile von Triton Inference Server

Die Verwendung von Triton Inference Server mit Ultralytics YOLO11 bietet mehrere Vorteile:

Automatische Stapelverarbeitung: Fasst mehrere KI-Anfragen zusammen, bevor sie verarbeitet werden, wodurch die Latenzzeit verringert und die Inferenzgeschwindigkeit erhöht wird.
Kubernetes-Integration: Cloud-natives Design arbeitet nahtlos mit Kubernetes für die Verwaltung und Skalierung von KI-Anwendungen
Hardware-spezifische Optimierungen: Nutzt die Vorteile der NVIDIA für maximale Leistung
Flexibilität des Frameworks: Unterstützt mehrere KI-Frameworks wie TensorFlow, PyTorch, ONNX und TensorRT
Open-Source und anpassbar: Kann an spezifische Bedürfnisse angepasst werden und gewährleistet Flexibilität für verschiedene KI-Anwendungen

Voraussetzungen

Vergewissern Sie sich, dass Sie über die folgenden Voraussetzungen verfügen, bevor Sie fortfahren:

Docker auf Ihrem Rechner installiert
Installieren Sie tritonclient:
```
pip install tritonclient[all]
```

Exportieren von YOLO11 in das Format ONNX

Bevor das Modell auf Triton bereitgestellt wird, 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. Verwenden Sie das export Funktion aus der YOLO Klasse:

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 von Triton Model Repository

Das Triton Model Repository ist ein Speicherort, an dem Triton auf Modelle zugreifen und diese laden kann.

Erstellen Sie die erforderliche 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 Modell ONNX in das Repository Triton :

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 von Triton Inference Server

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

Reinigen Sie den Behälter:

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

TensorRT (optional)

Für noch mehr Leistung können Sie TensorRT mit Triton Inference Server verwenden. TensorRT ist ein hochleistungsfähiger Deep-Learning-Optimierer, der speziell für NVIDIA entwickelt wurde und die Inferenzgeschwindigkeit erheblich steigern kann.

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

Bis zu 36-mal schnellere Inferenz im Vergleich zu nicht optimierten Modellen
Hardware-spezifische Optimierungen für maximale GPU
Unterstützung für Formate mit reduzierter Genauigkeit (INT8, FP16) unter Beibehaltung der Genauigkeit
Schichtenfusion zur Verringerung des Rechenaufwands

Um TensorRT direkt zu verwenden, können Sie Ihr YOLO11 in das TensorRT 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 finden Sie in der TensorRT .

Wenn Sie die oben genannten Schritte befolgen, können Sie Ultralytics YOLO11 Modelle effizient auf Triton Inference Server bereitstellen und ausführen und so eine skalierbare und leistungsstarke Lösung für Deep Learning Inferenzaufgaben bereitstellen. Sollten 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 kann ich Ultralytics YOLO11 mit NVIDIA Triton Inference Server einrichten?

Das Einrichten Ultralytics YOLO11 mit NVIDIA Triton Inference Server umfasst einige wichtige Schritte:

Exportieren Sie YOLO11 in das Format ONNX :

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

Führen Sie 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: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)

Mit diesem Setup können Sie YOLO11 Modelle effizient und in großem Umfang auf Triton Inference Server für hochleistungsfähige KI-Modellinferenz einsetzen.

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

Die Integration von Ultralytics YOLO11 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: Optimiert für NVIDIA GPUs, gewährleistet Triton Inference Server Hochgeschwindigkeits-Inferenzoperationen, perfekt für Echtzeitanwendungen wie z.B. Objekterkennung.
Ensemble und Modellversionierung: Der Ensemble-Modus von Triton ermöglicht die Kombination mehrerer Modelle zur Verbesserung der Ergebnisse, und die Modellversionierung unterstützt A/B-Tests und rollierende Updates.
Automatisches Batching: Triton fasst automatisch mehrere Inferenzanfragen zusammen, was den Durchsatz deutlich erhöht und die Latenzzeit verringert.
Vereinfachte Bereitstellung: Schrittweise Optimierung von KI-Workflows, ohne dass eine komplette Systemüberholung erforderlich ist, was eine effiziente Skalierung erleichtert.

Detaillierte Anweisungen zum Einrichten und Ausführen von YOLO11 mit Triton finden Sie in der Einrichtungsanleitung.

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

Die Verwendung des ONNX (Open Neural Network Exchange) für Ihr Ultralytics YOLO11 vor der Bereitstellung auf dem NVIDIA Triton Inference Server bietet mehrere entscheidende 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 Bereitstellungsumgebungen, darunter Triton, sind für ONNX optimiert und ermöglichen schnellere Schlussfolgerungen und eine bessere Leistung.
Einfache Bereitstellung: ONNX wird von vielen Frameworks und Plattformen unterstützt, was den Bereitstellungsprozess unter verschiedenen Betriebssystemen und Hardwarekonfigurationen vereinfacht.
Framework-Unabhängigkeit: Nach der Konvertierung in ONNX ist Ihr Modell nicht mehr an sein ursprüngliches Framework gebunden, wodurch es leichter übertragbar ist.
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 in der ONNX befolgen, um den Prozess abzuschließen.

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

Ja, Sie können Inferenzen mit dem Ultralytics YOLO11 auf dem NVIDIA Triton Inference Server durchführen. Sobald Ihr Modell im Triton Model Repository eingerichtet ist und der Server läuft, können Sie Ihr Modell wie folgt laden und Inferenzen durchfü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 zu verwenden. Eine ausführliche Anleitung zum Einrichten und Ausführen von Triton Server mit YOLO11 finden Sie im Abschnitt triton Inference Server ausführen.

Wie steht Ultralytics YOLO11 im Vergleich zu den Modellen TensorFlow und PyTorch für den Einsatz?

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

Leistung in Echtzeit: Optimiert für Echtzeit-Objekterkennungsaufgaben, bietet YOLO11 modernste Genauigkeit und Geschwindigkeit und ist damit ideal für Anwendungen, die eine Live-Videoanalyse erfordern.
Benutzerfreundlichkeit: YOLO11 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: YOLO11 enthält Funktionen wie dynamisches Laden von Modellen, Modellversionierung und Ensemble-Inferenz, die für skalierbare und zuverlässige KI-Implementierungen entscheidend sind.
Vereinfachte API: Die Ultralytics bietet eine einheitliche Schnittstelle für verschiedene Einsatzziele, was die Lernkurve und die Entwicklungszeit reduziert.
Edge-Optimierung: Die YOLO11 wurden speziell für den Einsatz am Rande des Netzwerks entwickelt und bieten selbst auf Geräten mit eingeschränkten Ressourcen eine hervorragende Leistung.

Weitere Einzelheiten finden Sie in der Anleitung für den Modellexport unter Einsatzoptionen.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 8 Tagen