Zum Inhalt springen

Triton Inferenz-Server mit Ultralytics YOLO11

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:

  • Bedienung mehrerer Modelle von einer einzigen Serverinstanz aus.
  • 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.

Voraussetzungen

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

  • Docker ist 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

# Retreive metadata during export
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.

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

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

# (Optional) Enable TensorRT for GPU inference
# First run will be slow due to TensorRT engine conversion
data = """
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"
      }
    }
  }
}
parameters {
  key: "metadata"
  value: {
    string_value: "%s"
  }
}
""" % metadata[0]

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)

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:

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

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

  3. 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.

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 Formats ONNX (Open Neural Network Exchange) für Ihr Ultralytics YOLO11 für Ihr Modell, bevor Sie es auf NVIDIA Triton Inference Server bereitstellen, 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 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.

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 Exportanleitung befolgen, um den Vorgang abzuschließen.

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

Ja, Sie können die Inferenz mit dem Ultralytics YOLO11 Modell auf 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 Inferenz 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")

Eine ausführliche Anleitung zum Einrichten und Ausführen von Triton Server mit YOLO11 finden Sie im Abschnitt Ausführen von triton Inferenzserver.

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

Ultralytics YOLO11 bietet im Vergleich zu den Bereitstellungsmodellen TensorFlow und PyTorch mehrere einzigartige Vorteile:

  • 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.

Weitere Einzelheiten finden Sie im Leitfaden zur Bereitstellung des Modells.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 9 Tagen
Y-T-G UltralyticsAssistent glenn-jocher

Kommentare