Nvidia TensorRT RTX Execution Provider

Der Nvidia TensorRT RTX Execution Provider ist der bevorzugte Execution Provider für GPU-Beschleunigung auf Consumer-Hardware (RTX-PCs). Er ist einfacher zu verwenden als der auf Rechenzentren fokussierte Legacy-TensorRT Execution Provider und leistungsfähiger als CUDA EP. Nur einige der Dinge, die ihn auf RTX-PCs besser geeignet machen als unseren Legacy-TensorRT Execution Provider:

• Deutlich geringerer Footprint
• Deutlich schnellere Modellkompilierungs-/Ladezeiten.
• Bessere Benutzerfreundlichkeit in Bezug auf die Nutzung von gecachten Modellen über mehrere RTX-GPUs hinweg.

Der Nvidia TensorRT RTX Execution Provider in ONNX Runtime nutzt NVIDIAs TensorRT RTX Deep Learning Inferencing Engine (TODO: Korrekten Link zur TRT RTX-Dokumentation bereitstellen, sobald verfügbar), um ONNX-Modelle auf RTX-GPUs zu beschleunigen. Microsoft und NVIDIA haben eng zusammengearbeitet, um den TensorRT RTX Execution Provider mit ONNX Runtime zu integrieren.

Derzeit unterstützt TensorRT RTX RTX-GPUs ab der Ampere-Architektur oder neuer. Unterstützung für Turing-GPUs ist in Kürze verfügbar.

Inhalt

• Installieren
• Erstellung aus Quelle
• Voraussetzungen
• Verwendung
• Konfigurationen
• NV TensorRT RTX EP Caches
• Performance-Tuning

Installieren

Bitte wählen Sie die Nvidia TensorRT RTX-Version von Onnx Runtime: https://onnxruntime.de/docs/install. (TODO!)

Aus dem Quellcode kompilieren

Siehe Build-Anweisungen.

Voraussetzungen

ONNX Runtime	TensorRT-RTX	CUDA
main	1.0	12.0-12.9
1.22	1.0	12.0-12.9

Verwendung

C/C++

const auto& api = Ort::GetApi();
Ort::SessionOptions session_options;
api.SessionOptionsAppendExecutionProvider(session_options, "NvTensorRtRtx", nullptr, nullptr, 0);
Ort::Session session(env, model_path, session_options);

Die Details der C-API finden Sie hier.

Python

Um den TensorRT RTX Execution Provider zu verwenden, müssen Sie den TensorRT RTX Execution Provider explizit bei der Instanziierung der InferenceSession registrieren.

import onnxruntime as ort
sess = ort.InferenceSession('model.onnx', providers=['NvTensorRtRtxExecutionProvider'])

Konfigurationen

TensorRT RTX-Einstellungen können über TensorRT Execution Provider Session Option konfiguriert werden.

Hier sind Beispiele und verschiedene Szenarien zum Einstellen von NV TensorRT RTX EP Session-Optionen

Klicken Sie unten für ein Python API-Beispiel

import onnxruntime as ort

model_path = '<path to model>'

# note: for bool type options in python API, set them as False/True
provider_options = {
  'device_id': 0,
  'nv_dump_subgraphs': False,
  'nv_detailed_build_log': True,
  'user_compute_stream': stream_handle
}

sess_opt = ort.SessionOptions()
sess = ort.InferenceSession(model_path, sess_options=sess_opt, providers=[('NvTensorRTRTXExecutionProvider', provider_options)])

Klicken Sie unten für ein C++ API-Beispiel

Ort::SessionOptions session_options;

cudaStream_t cuda_stream;
cudaStreamCreate(&cuda_stream);

// Need to put the CUDA stream handle in a string
char streamHandle[32];
sprintf_s(streamHandle, "%lld", (uint64_t)cuda_stream);

const auto& api = Ort::GetApi();
std::vector<const char*> option_keys = {
    "device_id",
    "user_compute_stream",  // this implicitly sets "has_user_compute_stream"
};
std::vector<const char*> option_values = {
    "1",
    streamHandle
};

Ort::ThrowOnError(api.SessionOptionsAppendExecutionProvider(session_options, "NvTensorRtRtx", option_keys.data(), option_values.data(), option_keys.size()));

Szenario

Szenario	NV TensorRT RTX EP Session Option	Typ
GPU-ID für die Ausführung angeben	device_id	int
Benutzerdefinierten Compute-Stream für GPU-Operationen festlegen	user_compute_stream	string
Speichernutzungslimit für NV TensorRT RTX EP GPU festlegen	nv_max_workspace_size	int
Optimierte Teilgraphen zum Debuggen ausgeben	nv_dump_subgraphs	bool
CUDA-Graph zur Reduzierung des Start-Overheads erfassen	nv_cuda_graph_enable	bool
Detaillierte Protokollierung der Build-Schritte aktivieren	nv_detailed_build_log	bool
Mindestformen definieren	nv_profile_min_shapes	string
Maximalformen definieren	nv_profile_max_shapes	string
Optimale Formen definieren	nv_profile_opt_shapes	string

Hinweis: Für boolesche Optionen weisen Sie diese mit True/False in Python oder 1/0 in C++ zu.

Execution Provider Optionen

TensorRT RTX-Konfigurationen können über Execution Provider-Optionen festgelegt werden. Dies ist nützlich, wenn jedes Modell und jede Inferenzsitzung eigene Konfigurationen haben. Alle Konfigurationen sollten explizit gesetzt werden, andernfalls wird der Standardwert übernommen.

device_id

• Beschreibung: GPU-Geräte-ID.
• Standardwert: 0

user_compute_stream

• Beschreibung: Definiert den Compute-Stream, auf dem die Inferenz ausgeführt werden soll. Dies setzt implizit die Option has_user_compute_stream. Der Stream-Handle muss als dezimale Zahl in einen String konvertiert und wie im obigen Beispiel gezeigt an die Session-Optionen übergeben werden.

• Dies kann auch über die Python-API gesetzt werden.

  • z.B. Der aus PyTorch erfasste CUDA-Stream kann an ORT-NV TensorRT RTX EP übergeben werden. Klicken Sie unten, um den Beispielcode anzuzeigen

    import onnxruntime as ort
    import torch
    ...
    sess = ort.InferenceSession('model.onnx')
    if torch.cuda.is_available():
        s = torch.cuda.Stream()
        provider_options = {
          'device_id': 0,
          'user_compute_stream': str(s.cuda_stream)
        }
    
        sess = ort.InferenceSession(
          model_path,
          providers=[('NvTensorRtRtxExecutionProvider', provider_options)]
        )
    
        options = sess.get_provider_options()
        assert "NvTensorRtRtxExecutionProvider" in options
        assert options["NvTensorRtRtxExecutionProvider"].get("user_compute_stream", "") == str(s.cuda_stream)
    ...
    

• Um vom Benutzer-Compute-Stream zu profitieren, wird empfohlen, I/O Binding zu verwenden, um Ein- und Ausgaben an Tensoren im Gerät zu binden.

nv_max_workspace_size

• Beschreibung: Maximale Workspace-Größe in Bytes für die TensorRT RTX-Engine.

• Standardwert: 0 (TensorRT wählt das Optimum).

nv_dump_subgraphs

• Beschreibung: Gibt die Teilgraphen aus, wenn das ONNX über mehrere Execution Provider aufgeteilt wurde.
  • Dies kann beim Debuggen von Teilgraphen helfen, z. B. durch Verwendung von trtexec --onnx subgraph_1.onnx und Überprüfung der Ausgaben des Parsers.

nv_detailed_build_log

• Beschreibung: Aktiviert die detaillierte Protokollierung von Build-Schritten in NV TensorRT RTX EP mit Zeitmessung für jeden Engine-Build.

nv_cuda_graph_enable

• Beschreibung: Dies erfasst einen CUDA-Graphen, der bei Netzwerken mit vielen kleinen Schichten drastisch helfen kann, da er den Start-Overhead auf der CPU reduziert.

nv_profile_min_shapes

nv_profile_max_shapes

nv_profile_opt_shapes

• Beschreibung: Build mit expliziten dynamischen Formen unter Verwendung eines Profils mit den angegebenen Min-/Max-/Opt-Formen.
  • Standardmäßig unterstützen TensorRT RTX-Engines dynamische Formen. Zur Leistungssteigerung ist es möglich, einen oder mehrere explizite Formbereiche anzugeben.
  • Das Format der Profilformen ist input_tensor_1:dim_1xdim_2x...,input_tensor_2:dim_3xdim_4x...,...
    • Diese drei Flags sollten alle angegeben werden, um die Funktion für explizite Profilformen zu aktivieren.
  • Beachten Sie, dass mehrere TensorRT RTX-Profile aktiviert werden können, indem mehrere Formen für denselben Eingabe-Tensor übergeben werden.
  • Weitere Informationen zu Optimierungsprofilen finden Sie in der TensorRT-Dokumentation.

NV TensorRT RTX EP Caches

Es gibt zwei Haupt-TRT RTX EP-Caches

• Eingebettetes Engine-Modell / EPContext-Modell
• Interner TensorRT RTX-Cache

Der interne TensorRT RTX-Cache wird automatisch vom EP verwaltet. Der Benutzer muss nur das EPContext-Caching verwalten. Caching ist wichtig, um die Zeit für die Sitzungserstellung drastisch zu reduzieren.

TensorRT RTX trennt die Kompilierung in eine Ahead-of-Time (AOT) kompilierte Engine und eine Just-in-Time (JIT) Kompilierung. Die AOT-Kompilierung kann als EPcontext-Modell gespeichert werden. Dieses Modell ist mit mehreren GPU-Generationen kompatibel. Beim Laden eines solchen EPcontext-Modells wird TensorRT RTX die Engine Just-in-Time kompilieren, um sie an die verwendete GPU anzupassen. Dieser JIT-Prozess wird durch den internen Cache von TensorRT RTX beschleunigt. Ein Anwendungsbeispiel finden Sie hier: https://github.com/microsoft/onnxruntime/blob/main/onnxruntime/test/providers/nv_tensorrt_rtx/nv_basic_test.cc

Mehr über eingebettete Engine-Modelle / EPContext-Modelle

• TODO: Entscheidung über einen Plan für die standardmäßige Verwendung von gewichtsreduzierten Engines. Implementierung des EPs korrigieren, um dies zu ermöglichen. Motivation erklären und Beispiel für die Verwendung der richtigen Optionen in diesem Dokument geben.
• EPContext-Modelle ermöglichen auch das Verpacken einer extern kompilierten Engine, z. B. mit trtexec. Ein Python-Skript, das eine solche vorcompilierte Engine in eine ONNX-Datei verpacken kann, ist in den Python-Tools enthalten. (TODO: Dokumentieren, wie dies mit gewichtsreduzierten Engines funktioniert).

Performance-Tuning

Für die Leistungsoptimierung beachten Sie die Hinweise auf dieser Seite: ONNX Runtime Leistungsoptimierung

Bei Verwendung von onnxruntime_perf_test verwenden Sie das Flag -e nvtensorrttrx.

TensorRT RTX Plugin-Unterstützung

TensorRT RTX unterstützt keine Plugins.