TensorRT auf NVIDIA-Karte einrichten: KI-Inferenz optimieren

Symbolbild, KI-generiert (gpt-image-1)

TensorRT ist NVIDIAs Plattform zur Optimierung von KI-Inferenz. Durch Schichten-Fusion, Kernel-Autotuning und optionale INT8-Quantisierung erreicht TensorRT auf der gleichen GPU 2–8× höheren Durchsatz gegenüber ungeoptimierten PyTorch- oder ONNX-Modellen. Dieser Artikel zeigt, wie TensorRT auf einer NVIDIA-Karte eingerichtet wird – vom ONNX-Modell zur optimierten TensorRT-Engine.

Wann TensorRT sinnvoll ist

TensorRT lohnt sich immer dann, wenn: - Echtzeit-Anforderungen bestehen (< 50 ms Inferenzzeit pro Frame) - Mehrere KI-Modelle parallel auf einer GPU laufen sollen - GPU-Ressourcen möglichst effizient genutzt werden müssen (keine Cloud-Skalierung möglich) - Die Zielplattform fix ist (TensorRT-Engines sind GPU-spezifisch, nicht portierbar)

Voraussetzungen

• Ubuntu 22.04 LTS mit NVIDIA-Treiber und CUDA installiert
• TensorRT installieren:

sudo apt install tensorrt
# Alternativ über pip:
pip install tensorrt

Versionscheck:

import tensorrt as trt
print(trt.__version__)

Schritt 1: Modell nach ONNX exportieren

TensorRT arbeitet am besten mit ONNX-Modellen als Eingangsformat. Export aus PyTorch:

import torch
from ultralytics import YOLO

model = YOLO('yolov8n.pt')

# Export nach ONNX
model.export(format='onnx', opset=17, dynamic=False, imgsz=640)
# Ergebnis: yolov8n.onnx

Schritt 2: TensorRT-Engine erstellen

Variante A: trtexec (CLI-Tool)

trtexec \
  --onnx=yolov8n.onnx \
  --saveEngine=yolov8n_fp16.trt \
  --fp16 \
  --workspace=4096 \
  --verbose

--fp16: FP16 Precision – halbiert Speicherbedarf, ~2× schneller gegenüber FP32, kaum Genauigkeitsverlust.

Variante B: Python API

import tensorrt as trt

logger = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(logger)
network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
parser = trt.OnnxParser(network, logger)

with open('yolov8n.onnx', 'rb') as f:
    parser.parse(f.read())

config = builder.create_builder_config()
config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 32)  # 4 GB
config.set_flag(trt.BuilderFlag.FP16)

engine = builder.build_serialized_network(network, config)
with open('yolov8n_fp16.trt', 'wb') as f:
    f.write(engine)

Schritt 3: Engine laden und Inferenz ausführen

import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

# Engine laden
logger = trt.Logger(trt.Logger.WARNING)
with open('yolov8n_fp16.trt', 'rb') as f:
    runtime = trt.Runtime(logger)
    engine = runtime.deserialize_cuda_engine(f.read())

context = engine.create_execution_context()

# Einfacher Inferenz-Test (Eingabe/Ausgabe-Puffer)
input_shape = (1, 3, 640, 640)
input_data = np.random.rand(*input_shape).astype(np.float32)

In der Praxis: Ultralytics-Bibliothek unterstützt TensorRT direkt:

from ultralytics import YOLO

model = YOLO('yolov8n_fp16.trt')  # TRT-Engine direkt laden
results = model('image.jpg', device='cuda')
print(f"Inferenz: {results[0].speed['inference']:.1f} ms")

INT8-Quantisierung

INT8 halbiert den Speicherbedarf nochmals und erhöht den Durchsatz weiter, erfordert aber einen Kalibrierungsdatensatz:

trtexec \
  --onnx=yolov8n.onnx \
  --saveEngine=yolov8n_int8.trt \
  --int8 \
  --calib=calibration_cache.bin

Genauigkeitsverlust durch INT8 ist anwendungsabhängig – immer auf dem Ziel-Datensatz evaluieren.

Benchmarking

trtexec --loadEngine=yolov8n_fp16.trt --batch=1 --iterations=1000

Ausgabe enthält: Durchschnittliche Inferenzzeit, Throughput (Inferences/s), GPU-Speicherbedarf.

Typische Ergebnisse auf NVIDIA RTX 3060: - YOLOv8n PyTorch FP32: ~8 ms - YOLOv8n TensorRT FP16: ~3 ms - YOLOv8n TensorRT INT8: ~2 ms

Videoströme: DeepStream statt Einzelbild-Inferenz

Wer nicht einzelne Bilder, sondern kontinuierliche Kameraströme verarbeitet, sollte den Umweg über eine eigene Schleife nicht selbst bauen. NVIDIAs DeepStream SDK setzt auf TensorRT auf und bringt die Teile mit, die in der Praxis Zeit kosten: Hardware-Dekodierung des Videostroms, Batching mehrerer Kameras auf eine GPU, Tracking über Frames hinweg und die Ausgabe als Metadatenstrom. Bei mehreren Kameras an einem Rechner ist das der Unterschied zwischen einer GPU, die dekodiert, und einer GPU, die rechnet.

Fazit

TensorRT ist der entscheidende Schritt, um KI-Modelle für den Edge-Produktiveinsatz zu optimieren. Der FP16-Workflow ist unkompliziert und liefert sofort messbare Verbesserungen. TensorRT-Engines sind GPU-spezifisch – für jede GPU-Generation separat bauen.

Passende PCIe AI-Karten: PCIe AI-Karten GPU-Karten.

Weiterführende Dokumentation

• NVIDIA TensorRT – Offizielle Dokumentation
• NVIDIA TensorRT Best Practices
• Ultralytics YOLOv8 TensorRT Export
• ONNX Exporter – PyTorch Dokumentation

Zurück zum Wiki-Inhaltsverzeichnis.

---