Triton Inferenz-Server mit Ultralytics YOLOv8

Der Triton Inference Server (früher bekannt als TensorRT Inference Server) ist eine von NVIDIA entwickelte Open-Source-Softwarelösung. Sie 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 Inferenz-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.

1. Erstelle die notwendige Verzeichnisstruktur:

   from pathlib import Path
   
   # Define paths
   triton_repo_path = Path('tmp') / 'triton_repo'
   triton_model_path = triton_repo_path / 'yolo'
   
   # Create directories
   (triton_model_path / '1').mkdir(parents=True, exist_ok=True)
   

2. 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 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(f'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.

Kommentare