From c15ff43d610a23d087b0e4a5209fd25eb3a4070f Mon Sep 17 00:00:00 2001 From: Tao Zhang Date: Fri, 18 Sep 2026 14:12:12 -0400 Subject: [PATCH 1/5] Add in-tree isaac_deploy_trt and optimize_graph TensorRT rewrite. Vendors TensorRT ONNX surgery under packages/isaac_deploy_trt, exposes optimize_graph(trt_compatible=True) after compile_graph, and stamps YAML checksums plus parameters.tensorrt_compatible on exported ONNX models. --- .github/workflows/ci.yml | 4 +- AGENTS.md | 27 +- docs/source/api/index.rst | 33 + docs/source/generated_configs.rst | 14 + docs/source/guides/debugging.rst | 24 + leapp/__init__.py | 3 +- leapp/backends/onnx_export_backend.py | 39 + leapp/backends/tensorrt_leapp_bundle.py | 281 ++ leapp/backends/tensorrt_onnx_graph_split.py | 428 ++ leapp/backends/tensorrt_plugin_replace.py | 257 ++ leapp/cli.py | 40 + leapp/leapp.py | 70 + packages/isaac_deploy_trt/.gitignore | 12 + packages/isaac_deploy_trt/LICENSE | 176 + packages/isaac_deploy_trt/README.md | 241 ++ packages/isaac_deploy_trt/pyproject.toml | 31 + .../generate_tensorrt_supported_layers.py | 21 + .../scripts/merge_pipeline.py | 24 + .../src/isaac_deploy_trt/__init__.py | 63 + .../src/isaac_deploy_trt/catalog.py | 219 + .../src/isaac_deploy_trt/cli.py | 253 ++ .../src/isaac_deploy_trt/generate_cmd.py | 149 + .../src/isaac_deploy_trt/headers.py | 269 ++ .../src/isaac_deploy_trt/pipeline_merge.py | 458 +++ .../src/isaac_deploy_trt/platform_catalog.py | 1159 ++++++ .../src/isaac_deploy_trt/prepare.py | 118 + .../src/isaac_deploy_trt/surgery.py | 646 +++ .../src/isaac_deploy_trt/tensorrt_onnx_ops.py | 1175 ++++++ .../src/isaac_deploy_trt/validate.py | 137 + .../tensorrt_catalogs/index.json | 85 + .../tensorrt_catalogs/v10.11/index.json | 24 + .../v10.11/tensorrt_layers_cuda132_dgx.json | 3522 ++++++++++++++++ .../v10.11/tensorrt_layers_cuda132_dgx.md | 292 ++ .../v10.11/tensorrt_layers_cuda132_orin.json | 3201 +++++++++++++++ .../v10.11/tensorrt_layers_cuda132_orin.md | 292 ++ .../v10.11/tensorrt_layers_cuda132_thor.json | 3520 ++++++++++++++++ .../v10.11/tensorrt_layers_cuda132_thor.md | 291 ++ .../v10.11/tensorrt_layers_cuda132_x86.json | 3522 ++++++++++++++++ .../v10.11/tensorrt_layers_cuda132_x86.md | 292 ++ .../tensorrt_catalogs/v10.13.3/index.json | 25 + .../v10.13.3/tensorrt_layers_cuda132_dgx.json | 3525 ++++++++++++++++ .../v10.13.3/tensorrt_layers_cuda132_dgx.md | 292 ++ .../tensorrt_layers_cuda132_orin.json | 3204 +++++++++++++++ .../v10.13.3/tensorrt_layers_cuda132_orin.md | 292 ++ .../tensorrt_layers_cuda132_thor.json | 3523 ++++++++++++++++ .../v10.13.3/tensorrt_layers_cuda132_thor.md | 291 ++ .../v10.13.3/tensorrt_layers_cuda132_x86.json | 3525 ++++++++++++++++ .../v10.13.3/tensorrt_layers_cuda132_x86.md | 292 ++ .../tensorrt_catalogs/v10.14/index.json | 22 + .../v10.14/tensorrt_layers_cuda132_dgx.json | 3536 ++++++++++++++++ .../v10.14/tensorrt_layers_cuda132_dgx.md | 294 ++ .../v10.14/tensorrt_layers_cuda132_orin.json | 3215 +++++++++++++++ .../v10.14/tensorrt_layers_cuda132_orin.md | 294 ++ .../v10.14/tensorrt_layers_cuda132_thor.json | 3534 ++++++++++++++++ .../v10.14/tensorrt_layers_cuda132_thor.md | 293 ++ .../v10.14/tensorrt_layers_cuda132_x86.json | 3536 ++++++++++++++++ .../v10.14/tensorrt_layers_cuda132_x86.md | 294 ++ .../tensorrt_catalogs/v10.15/index.json | 22 + .../v10.15/tensorrt_layers_cuda132_dgx.json | 3550 ++++++++++++++++ .../v10.15/tensorrt_layers_cuda132_dgx.md | 296 ++ .../v10.15/tensorrt_layers_cuda132_orin.json | 3229 +++++++++++++++ .../v10.15/tensorrt_layers_cuda132_orin.md | 296 ++ .../v10.15/tensorrt_layers_cuda132_thor.json | 3548 ++++++++++++++++ .../v10.15/tensorrt_layers_cuda132_thor.md | 295 ++ .../v10.15/tensorrt_layers_cuda132_x86.json | 3550 ++++++++++++++++ .../v10.15/tensorrt_layers_cuda132_x86.md | 296 ++ .../tensorrt_catalogs/v10.16/index.json | 22 + .../v10.16/tensorrt_layers_cuda132_dgx.json | 3564 +++++++++++++++++ .../v10.16/tensorrt_layers_cuda132_dgx.md | 298 ++ .../v10.16/tensorrt_layers_cuda132_orin.json | 3243 +++++++++++++++ .../v10.16/tensorrt_layers_cuda132_orin.md | 298 ++ .../v10.16/tensorrt_layers_cuda132_thor.json | 3562 ++++++++++++++++ .../v10.16/tensorrt_layers_cuda132_thor.md | 297 ++ .../v10.16/tensorrt_layers_cuda132_x86.json | 3564 +++++++++++++++++ .../v10.16/tensorrt_layers_cuda132_x86.md | 298 ++ .../tensorrt_catalogs/v10.7.0/index.json | 22 + .../v10.7.0/tensorrt_layers_cuda132_dgx.json | 3508 ++++++++++++++++ .../v10.7.0/tensorrt_layers_cuda132_dgx.md | 292 ++ .../v10.7.0/tensorrt_layers_cuda132_orin.json | 3190 +++++++++++++++ .../v10.7.0/tensorrt_layers_cuda132_orin.md | 292 ++ .../v10.7.0/tensorrt_layers_cuda132_thor.json | 3506 ++++++++++++++++ .../v10.7.0/tensorrt_layers_cuda132_thor.md | 291 ++ .../v10.7.0/tensorrt_layers_cuda132_x86.json | 3508 ++++++++++++++++ .../v10.7.0/tensorrt_layers_cuda132_x86.md | 292 ++ .../tensorrt_catalogs/v10.8.0/index.json | 22 + .../v10.8.0/tensorrt_layers_cuda132_dgx.json | 3518 ++++++++++++++++ .../v10.8.0/tensorrt_layers_cuda132_dgx.md | 292 ++ .../v10.8.0/tensorrt_layers_cuda132_orin.json | 3197 +++++++++++++++ .../v10.8.0/tensorrt_layers_cuda132_orin.md | 292 ++ .../v10.8.0/tensorrt_layers_cuda132_thor.json | 3516 ++++++++++++++++ .../v10.8.0/tensorrt_layers_cuda132_thor.md | 291 ++ .../v10.8.0/tensorrt_layers_cuda132_x86.json | 3518 ++++++++++++++++ .../v10.8.0/tensorrt_layers_cuda132_x86.md | 292 ++ .../tensorrt_catalogs/v11.2/index.json | 24 + .../v11.2/tensorrt_layers_cuda132_dgx.json | 3555 ++++++++++++++++ .../v11.2/tensorrt_layers_cuda132_dgx.md | 298 ++ .../v11.2/tensorrt_layers_cuda132_orin.json | 3234 +++++++++++++++ .../v11.2/tensorrt_layers_cuda132_orin.md | 298 ++ .../v11.2/tensorrt_layers_cuda132_thor.json | 3553 ++++++++++++++++ .../v11.2/tensorrt_layers_cuda132_thor.md | 297 ++ .../v11.2/tensorrt_layers_cuda132_x86.json | 3555 ++++++++++++++++ .../v11.2/tensorrt_layers_cuda132_x86.md | 298 ++ .../isaac_deploy_trt/tests/test_catalog.py | 89 + .../tests/test_generate_catalogs.py | 271 ++ .../tests/test_pipeline_merge.py | 271 ++ .../isaac_deploy_trt/tests/test_surgery.py | 142 + pyproject.toml | 14 +- scripts/make_trt_aligned_leapp_bundle.py | 54 + tests/unit_tests/test_optimize_graph.py | 104 + .../unit_tests/test_tensorrt_leapp_bundle.py | 249 ++ .../test_tensorrt_onnx_graph_split.py | 128 + .../test_tensorrt_plugin_replace.py | 149 + 112 files changed, 128039 insertions(+), 10 deletions(-) create mode 100644 leapp/backends/tensorrt_leapp_bundle.py create mode 100644 leapp/backends/tensorrt_onnx_graph_split.py create mode 100644 leapp/backends/tensorrt_plugin_replace.py create mode 100644 leapp/cli.py create mode 100644 packages/isaac_deploy_trt/.gitignore create mode 100644 packages/isaac_deploy_trt/LICENSE create mode 100644 packages/isaac_deploy_trt/README.md create mode 100644 packages/isaac_deploy_trt/pyproject.toml create mode 100755 packages/isaac_deploy_trt/scripts/generate_tensorrt_supported_layers.py create mode 100755 packages/isaac_deploy_trt/scripts/merge_pipeline.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/__init__.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/catalog.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/generate_cmd.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/headers.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/platform_catalog.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/index.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.md create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.json create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.md create mode 100644 packages/isaac_deploy_trt/tests/test_catalog.py create mode 100644 packages/isaac_deploy_trt/tests/test_generate_catalogs.py create mode 100644 packages/isaac_deploy_trt/tests/test_pipeline_merge.py create mode 100644 packages/isaac_deploy_trt/tests/test_surgery.py create mode 100644 scripts/make_trt_aligned_leapp_bundle.py create mode 100644 tests/unit_tests/test_optimize_graph.py create mode 100644 tests/unit_tests/test_tensorrt_leapp_bundle.py create mode 100644 tests/unit_tests/test_tensorrt_onnx_graph_split.py create mode 100644 tests/unit_tests/test_tensorrt_plugin_replace.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f8644b43..91e157b2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -42,7 +42,7 @@ jobs: # Visualization modules ship with leapp; gated deps install on 3.11+. - name: Install package and test dependencies - run: python -m pip install -e ".[dev,test,warp-cu12]" cmake ninja + run: python -m pip install -e ".[dev,test,warp-cu12,graph-surgery]" cmake ninja - name: Build Warp runtime run: leapp-build-warp-runtime @@ -50,7 +50,7 @@ jobs: - name: Run pytest env: CMAKE_GENERATOR: Ninja - run: pytest tests/ packages/leapp-visualization/tests/ -v + run: pytest tests/ packages/leapp-visualization/tests/ packages/isaac_deploy_trt/tests/ -v docs: runs-on: ubuntu-latest diff --git a/AGENTS.md b/AGENTS.md index 73697815..4919d41c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -21,8 +21,9 @@ Python 3.10+ and PyTorch 2.6.0+. Visualization extras install only on | Warp tracing (`TracedWpArray`, APIC, `warp_op`) | `warp_support.md` | | Public annotate/lifecycle API or docs examples | `docs/source/api/index.rst` plus the matching guide under `docs/source/` | | Graph PNG layout | `packages/leapp-visualization/` | +| TensorRT ONNX rewrite / catalog / pipeline merge | `packages/isaac_deploy_trt/` | | Export backends | `leapp/backends/` | -| YAML / `InferenceManager` | `leapp/leapp.py` (`compile_graph`), `leapp/inference_manager.py`, `docs/source/generated_configs.rst` | +| YAML / `InferenceManager` | `leapp/leapp.py` (`compile_graph`, `optimize_graph`), `leapp/inference_manager.py`, `docs/source/generated_configs.rst` | Do not mix the skill's current `(context_obj, output_port)` identity with legacy `leapp_tag` helpers. The skill states which checkout you have. @@ -31,7 +32,7 @@ legacy `leapp_tag` helpers. The skill states which checkout you have. ``` leapp/ # installable package - leapp.py # start / stop / compile_graph / annotate facade + leapp.py # start / stop / compile_graph / optimize_graph / annotate facade export_manager.py # annotate.* implementations inference_manager.py # runtime loader for exported YAML backends/ # jit, onnx-dynamo, onnx-torchscript, pt2, none @@ -41,6 +42,7 @@ leapp/ # installable package datatypes/ # TracedData, TracedTensor, TracedNpArray, TracedWpArray utils/ # logging, TensorSemantics, enums, GraphConfigs packages/leapp-visualization/ # static PNG layout (ships with leapp) +packages/isaac_deploy_trt/ # TensorRT ONNX rewrite, catalogs, merge-pipeline docs/source/ # Sphinx (NVIDIA theme) examples/ # runnable samples; CI runs tests/test_examples/ tests/ @@ -54,12 +56,21 @@ allowed on `leapp.annotate` are listed in `AnnotateAPI._ALLOWED_APIS` in `leapp/leapp.py`. Do not add a consumer API without updating both, the docs, and tests. +Do not call `compile_graph()` before `stop()`. Call +`leapp.optimize_graph(trt_compatible=True)` after `compile_graph()` when +exported ONNX should be rewritten for TensorRT (`isaac_deploy_trt` / +`graph-surgery` extra). Use `leapp.start()`, `leapp.stop()`, and +`leapp.compile_graph()` for graph lifecycle. Use `annotate` only for +annotation APIs such as `method()`, `input_tensors()`, and +`output_tensors()`. + ## Commands ```bash python -m pip install -e ".[dev,test,warp-cu12]" # CUDA 12 python -m pip install -e ".[dev,test,warp-cu13]" # CUDA 13 -pytest tests/ packages/leapp-visualization/tests/ -v +python -m pip install -e ".[dev,graph-surgery]" # TensorRT ONNX rewrite extras +pytest tests/ packages/leapp-visualization/tests/ packages/isaac_deploy_trt/tests/ -v ``` Narrower (use these while iterating): @@ -71,6 +82,7 @@ Narrower (use these while iterating): | Annotate / I/O / state | `pytest tests/functional_tests/ -v` | | Examples | `pytest tests/test_examples/ -v` | | Visualization | `pytest packages/leapp-visualization/tests/ -v` (Python 3.11+) | +| TensorRT rewrite / catalogs | `pytest packages/isaac_deploy_trt/tests/ tests/unit_tests/test_optimize_graph.py tests/unit_tests/test_tensorrt_leapp_bundle.py -v` | | Warp tracing | see `warp_support.md` | ### Warp runtime build @@ -140,7 +152,7 @@ diff (`git diff origin/main...HEAD`) is the true delta. | `guides/export.rst` | Backends and `export_with` | | `guides/graph.rst` | State, `annotate.module`, feedback | | `guides/buffers.rst` | `static_outputs`, `mirror_leapp_tags` | -| `guides/debugging.rst` | Validation, logs, dry_run, `non_traced` | +| `guides/debugging.rst` | Validation, logs, dry_run, `non_traced`, TensorRT rewrite | | `leapp_runtime.rst` | `InferenceManager` | | `semantics/` | `TensorSemantics`, kinds, `TemporalAxis` | | `generated_configs.rst` | YAML shape | @@ -148,6 +160,13 @@ diff (`git diff origin/main...HEAD`) is the true delta. User-facing integration recipes belong here, not in this file. +TensorRT GraphSurgeon rewrites, op catalogs, and LEAPP DAG merge live in +`packages/isaac_deploy_trt`. After `compile_graph()`, +`optimize_graph(trt_compatible=True)` rewrites ONNX in the graph directory +and updates YAML checksums / `parameters.tensorrt_compatible`. Merge a DAG +for one Isaac `TensorRTNode` with +`isaac_deploy_trt merge-pipeline exported.yaml -o pipeline.onnx --rewrite`. + ## Guardrails when changing behavior - Prefer extending `TracedData` once (`_map_structure`, index lowering, diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index a3fbbc8b..479d0802 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -16,6 +16,7 @@ annotations. # or annotate.input_tensors() / annotate.output_tensors() leapp.stop() leapp.compile_graph(visualize=True) + leapp.optimize_graph(trt_compatible=True) Graph lifecycle =============== @@ -210,6 +211,38 @@ The method performs the complete pipeline: running. #. Log graph statistics. +``leapp.optimize_graph()`` +-------------------------- + +Post-compile graph optimizations. Call after ``compile_graph()``. + +Signature +~~~~~~~~~ + +.. code-block:: python + + leapp.optimize_graph( + trt_compatible: bool = False, + ) + +Parameters +~~~~~~~~~~ + +* ``trt_compatible`` (bool, optional): Rewrite exported ONNX files in the + graph output directory so TensorRT can parse them (UINT8 intermediate + Casts, Resize ``antialias``, rank-9 Reshape). Updates YAML checksums and + ``parameters.tensorrt_compatible``. Graph I/O names, dtypes, and shapes + are unchanged. Requires ``isaac_deploy_trt``. Defaults to ``False``. + +Behavior +~~~~~~~~ + +* Requires ``stop()`` and ``compile_graph()`` first (the graph YAML must + exist in the output directory). +* With no options enabled, logs a warning and returns ``{}``. +* Returns a dict of applied passes (for example + ``{"trt_compatible": }``). + ``GraphConfigs`` ---------------- diff --git a/docs/source/generated_configs.rst b/docs/source/generated_configs.rst index b47b26ac..d7d33e92 100644 --- a/docs/source/generated_configs.rst +++ b/docs/source/generated_configs.rst @@ -145,6 +145,20 @@ The ``models`` mapping is deterministically ordered. LEAPP guarantees: use these fields to verify that the model file has not changed since export. + ``opset_version`` + Present on ONNX backends. The ONNX opset used at export. + + ``tensorrt_compatible`` + Present on ONNX backends unless + ``backend_params={"annotate_tensorrt_compatible": False}``. + ``true`` means the exported graph's ops are in the TensorRT ONNX + support catalog (and, if ``validate_tensorrt_build`` was enabled, + TensorRT parsed/built the model). This does **not** switch the + runtime ``backend``; Isaac Deploy / Triton still load ``backend: onnx`` + unless the deployer maps this flag itself. Catalog ``true`` is not a + guarantee that TensorRT can build engines with dynamic shapes or + shape-tensor inputs without optimization profiles. + ``pipeline`` ------------ diff --git a/docs/source/guides/debugging.rst b/docs/source/guides/debugging.rst index afb2fdd6..daecf229 100644 --- a/docs/source/guides/debugging.rst +++ b/docs/source/guides/debugging.rst @@ -176,3 +176,27 @@ Disable session patches LEAPP patches for the tracing session (for example NumPy and torch interop). Use this only to test whether those patches are involved in a failure. + +TensorRT catalog and rewrite +============================ + +TensorRT op-catalog checks, GraphSurgeon rewrites, and DAG merge live in +the in-tree ``isaac_deploy_trt`` package (also the ``graph-surgery`` extra), +not in the LEAPP tracing CLI. After ``compile_graph()``, rewrite exported +ONNX in place with ``leapp.optimize_graph(trt_compatible=True)``. That +updates YAML checksums and ``parameters.tensorrt_compatible``. + +.. code-block:: bash + + pip install -e ".[graph-surgery]" + isaac_deploy_trt check --onnx path/to/model.onnx --strict + isaac_deploy_trt check --onnx-dir path/to/export_dir --build --strict + isaac_deploy_trt rewrite-dir path/to/export_dir -o path/to/export_dir_trt + isaac_deploy_trt merge-pipeline path/to/export.yaml -o pipeline.onnx --rewrite + +``--build`` also runs TensorRT parse/build (requires ``tensorrt``). +``--strict`` exits non-zero if catalog or TensorRT checks fail. + +Set ``backend_params={"annotate_tensorrt_compatible": False}`` to omit the +YAML field, or ``{"validate_tensorrt": True, "validate_tensorrt_build": True}`` +to require a TensorRT parse/build before marking ``true``. diff --git a/leapp/__init__.py b/leapp/__init__.py index 42dd6b35..33deb55d 100644 --- a/leapp/__init__.py +++ b/leapp/__init__.py @@ -30,7 +30,7 @@ # side effect, so it is available to tracing/export without explicit setup. from .leapp_graph.custom_operator_registry import warp_operator # noqa: F401 from .leapp_graph.datatypes.patching import FunctionPatch -from .leapp import annotate, start, stop, compile_graph +from .leapp import annotate, start, stop, compile_graph, optimize_graph from .utils.enums import InputKindEnum, OutputKindEnum from .utils.tensor_description import GraphConfigs, TensorSemantics, TemporalAxis @@ -49,6 +49,7 @@ "start", "stop", "compile_graph", + "optimize_graph", "__version__", "TensorSemantics", "TemporalAxis", diff --git a/leapp/backends/onnx_export_backend.py b/leapp/backends/onnx_export_backend.py index cc73b8b6..8c5143a8 100644 --- a/leapp/backends/onnx_export_backend.py +++ b/leapp/backends/onnx_export_backend.py @@ -20,6 +20,9 @@ class ONNXExportBackend(ExportBackend): def get_backend_metadata(self): metadata = {} metadata['opset_version'] = getattr(self, 'opset_version', _constants.ONNX_DEFAULT_OPSET) + tensorrt_compatible = getattr(self, 'tensorrt_compatible', None) + if tensorrt_compatible is not None: + metadata['tensorrt_compatible'] = bool(tensorrt_compatible) return metadata def get_backend_model_type(self): @@ -253,10 +256,46 @@ def save(self, save_path: str) -> Tuple[str, str, str]: _get_logger().error( f"ONNX model validation warning (model still saved): {e}") + # Record TensorRT compatibility in YAML (catalog check by default). + # Set backend_params={"annotate_tensorrt_compatible": False} to omit it. + # Enable parse/build with {"validate_tensorrt": True} and optional + # {"validate_tensorrt_build": True, "validate_tensorrt_strict": True}. + self._annotate_tensorrt_compatible(onnx_path) + md5sum, sha256sum = self._verify_model_location_and_get_hash(onnx_path) return onnx_path, md5sum, sha256sum + def _annotate_tensorrt_compatible(self, onnx_path: str) -> None: + annotate = self.backend_params.get('annotate_tensorrt_compatible', True) + validate = self.backend_params.get('validate_tensorrt', False) + if not annotate and not validate: + return + + try: + from isaac_deploy_trt.validate import ( + check_onnx_ops_against_tensorrt, + validate_onnx_for_tensorrt, + ) + except ImportError: + _get_logger().warning( + "isaac_deploy_trt is not installed; skipping TensorRT " + "compatibility annotation. pip install -e ./packages/isaac_deploy_trt" + ) + return + + if validate: + result = validate_onnx_for_tensorrt( + onnx_path, + build=self.backend_params.get('validate_tensorrt_build', False), + strict=self.backend_params.get('validate_tensorrt_strict', False), + ) + else: + result = check_onnx_ops_against_tensorrt(onnx_path) + + if annotate: + self.tensorrt_compatible = bool(result.ok) + def compile(self, m: torch.nn.Module = None) -> SimplifiedONNXProgram: raise NotImplementedError( "TorchExportBackend does not support compilation, please use torch-script or torch-trace instead") diff --git a/leapp/backends/tensorrt_leapp_bundle.py b/leapp/backends/tensorrt_leapp_bundle.py new file mode 100644 index 00000000..c38f1da2 --- /dev/null +++ b/leapp/backends/tensorrt_leapp_bundle.py @@ -0,0 +1,281 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Build a LEAPP export dir whose ONNX files are TensorRT-legal drop-ins. + +Keeps original filenames, graph I/O, pipeline YAML, and ``*.onnx.data`` +siblings so Isaac Deploy / Triton can consume the bundle without renaming +models. Graphs that need GraphSurgeon (UINT8 Cast, Resize antialias, rank-9 +Reshape) are rewritten; others are copied byte-for-byte. +""" + +from __future__ import annotations + +import hashlib +import os +import shutil +import tempfile +from dataclasses import dataclass, field +from typing import Dict, List, Optional + +import onnx +import yaml + +from isaac_deploy_trt.prepare import needs_tensorrt_rewrite +from isaac_deploy_trt.surgery import ( + apply_tensorrt_rewrites, + export_model, + graph_io_signature, + load_graph, + save_graph, +) +from isaac_deploy_trt.validate import check_onnx_ops_against_tensorrt +from leapp.utils.logging import _get_logger + + +_SKIP_ONNX_SUFFIXES = ("_trt.onnx",) + + +@dataclass +class AlignedOnnxResult: + """One ONNX file in an aligned TensorRT LEAPP bundle.""" + + filename: str + rewritten: bool + rewritten_nodes: List[str] = field(default_factory=list) + md5sum: str = "" + sha256sum: str = "" + + +@dataclass +class AlignedBundleResult: + """Result of ``align_leapp_export_for_tensorrt``.""" + + output_dir: str + models: List[AlignedOnnxResult] = field(default_factory=list) + yaml_paths: List[str] = field(default_factory=list) + + +def _file_hashes(path: str) -> tuple[str, str]: + with open(path, "rb") as handle: + data = handle.read() + return hashlib.md5(data).hexdigest(), hashlib.sha256(data).hexdigest() + + +def _copy_with_external_data(src_onnx: str, dst_onnx: str) -> None: + """Link unchanged ONNX (and ``*.data``) into the aligned dir.""" + src_onnx = os.path.abspath(src_onnx) + if os.path.lexists(dst_onnx): + os.remove(dst_onnx) + os.symlink(src_onnx, dst_onnx) + src_dir = os.path.dirname(src_onnx) + dst_dir = os.path.dirname(dst_onnx) + stem = os.path.basename(src_onnx) + for name in os.listdir(src_dir): + if not (name.startswith(stem + ".") or name == stem + ".data"): + continue + dst_data = os.path.join(dst_dir, name) + if os.path.lexists(dst_data): + os.remove(dst_data) + os.symlink(os.path.join(src_dir, name), dst_data) + + +def _has_external_data(onnx_path: str) -> bool: + parent = os.path.dirname(onnx_path) + stem = os.path.basename(onnx_path) + return os.path.isfile(os.path.join(parent, stem + ".data")) + + +def _save_rewritten( + graph, + src_onnx: str, + dst_onnx: str, +) -> None: + if _has_external_data(src_onnx): + model = export_model(graph) + data_name = os.path.basename(dst_onnx) + ".data" + data_path = os.path.join(os.path.dirname(dst_onnx), data_name) + if os.path.exists(data_path): + os.remove(data_path) + onnx.save( + model, + dst_onnx, + save_as_external_data=True, + all_tensors_to_one_file=True, + location=data_name, + size_threshold=1024, + convert_attribute=True, + ) + return + save_graph(graph, dst_onnx) + + +def _yaml_model_files(export_dir: str) -> Optional[List[str]]: + names: List[str] = [] + for filename in sorted(os.listdir(export_dir)): + if not filename.endswith((".yaml", ".yml")): + continue + path = os.path.join(export_dir, filename) + with open(path, "r", encoding="utf-8") as handle: + spec = yaml.safe_load(handle) or {} + models = spec.get("models") or {} + if not isinstance(models, dict): + continue + for model_cfg in models.values(): + params = (model_cfg or {}).get("parameters") or {} + model_path = params.get("model_path") + if model_path: + names.append(os.path.basename(str(model_path))) + # Preserve YAML order, drop duplicates. + return list(dict.fromkeys(names)) or None + + +def _update_yaml_parameters( + yaml_path: str, + hashes_by_filename: Dict[str, tuple[str, str]], + trt_compatible_by_filename: Dict[str, bool], +) -> None: + with open(yaml_path, "r", encoding="utf-8") as handle: + spec = yaml.safe_load(handle) or {} + models = spec.get("models") + if not isinstance(models, dict): + return + changed = False + for model_cfg in models.values(): + params = (model_cfg or {}).get("parameters") or {} + model_path = params.get("model_path") + if not model_path: + continue + filename = os.path.basename(str(model_path)) + if filename in hashes_by_filename: + md5sum, sha256sum = hashes_by_filename[filename] + if params.get("md5sum") != md5sum or params.get("sha256sum") != sha256sum: + params["md5sum"] = md5sum + params["sha256sum"] = sha256sum + changed = True + if filename in trt_compatible_by_filename: + flag = bool(trt_compatible_by_filename[filename]) + if params.get("tensorrt_compatible") != flag: + params["tensorrt_compatible"] = flag + changed = True + if not changed: + return + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle, sort_keys=False) + + +def align_leapp_export_for_tensorrt( + export_dir: str, + output_dir: str, +) -> AlignedBundleResult: + """Write a sibling LEAPP dir with TensorRT-legal ONNX and aligned YAML. + + Filenames stay ``preprocess_video.onnx``, ``backbone.onnx``, etc. Graph I/O + signatures are checked against the source models so Triton bindings still + match. ``*_trt.onnx`` sidecars in the source dir are skipped. + """ + export_dir = os.path.abspath(export_dir) + output_dir = os.path.abspath(output_dir) + if os.path.abspath(export_dir) == output_dir: + raise ValueError("output_dir must be different from export_dir") + os.makedirs(output_dir, exist_ok=True) + logger = _get_logger() + + yaml_names = _yaml_model_files(export_dir) + if yaml_names is not None: + onnx_files = [ + os.path.join(export_dir, name) + for name in yaml_names + if os.path.isfile(os.path.join(export_dir, name)) + ] + else: + onnx_files = [ + os.path.join(export_dir, name) + for name in sorted(os.listdir(export_dir)) + if name.endswith(".onnx") + and not any(name.endswith(suffix) for suffix in _SKIP_ONNX_SUFFIXES) + ] + + result = AlignedBundleResult(output_dir=output_dir) + hashes: Dict[str, tuple[str, str]] = {} + trt_compatible: Dict[str, bool] = {} + + for src in onnx_files: + filename = os.path.basename(src) + dst = os.path.join(output_dir, filename) + source_model = onnx.load(src, load_external_data=False) + source_io = graph_io_signature(source_model) + + if not needs_tensorrt_rewrite(source_model): + _copy_with_external_data(src, dst) + logger.info(f"Copied {filename} (already TensorRT-aligned I/O)") + rewritten_nodes: List[str] = [] + else: + graph = load_graph(src) + rewritten_nodes = apply_tensorrt_rewrites(graph) + _save_rewritten(graph, src, dst) + aligned = onnx.load(dst, load_external_data=False) + aligned_io = graph_io_signature(aligned) + if aligned_io != source_io: + raise RuntimeError( + f"TensorRT rewrite changed graph I/O for {filename}: " + f"{source_io} -> {aligned_io}" + ) + logger.info( + f"Rewrote {filename} for TensorRT ({len(rewritten_nodes)} node(s))" + ) + + md5sum, sha256sum = _file_hashes(dst) + hashes[filename] = (md5sum, sha256sum) + trt_compatible[filename] = bool( + check_onnx_ops_against_tensorrt(dst).ok + ) + result.models.append( + AlignedOnnxResult( + filename=filename, + rewritten=bool(rewritten_nodes), + rewritten_nodes=rewritten_nodes, + md5sum=md5sum, + sha256sum=sha256sum, + ) + ) + + for filename in os.listdir(export_dir): + if not filename.endswith((".yaml", ".yml")): + continue + src_yaml = os.path.join(export_dir, filename) + dst_yaml = os.path.join(output_dir, filename) + shutil.copy2(src_yaml, dst_yaml) + _update_yaml_parameters(dst_yaml, hashes, trt_compatible) + result.yaml_paths.append(dst_yaml) + + return result + + +def rewrite_leapp_export_for_tensorrt(export_dir: str) -> AlignedBundleResult: + """Apply TensorRT GraphSurgeon rewrites in place under ``export_dir``. + + Uses a temporary sibling directory so graph I/O and YAML checksums stay + aligned, then copies rewritten ONNX / YAML back onto the compiled graph. + Unchanged ONNX files are left as they were. + """ + export_dir = os.path.abspath(export_dir) + tmp_dir = tempfile.mkdtemp(prefix=".leapp_trt_opt_", dir=export_dir) + try: + result = align_leapp_export_for_tensorrt(export_dir, tmp_dir) + for name in os.listdir(tmp_dir): + src = os.path.join(tmp_dir, name) + dst = os.path.join(export_dir, name) + if os.path.islink(src) or not os.path.isfile(src): + continue + shutil.copy2(src, dst) + result.output_dir = export_dir + result.yaml_paths = [ + os.path.join(export_dir, os.path.basename(path)) + for path in result.yaml_paths + ] + return result + finally: + shutil.rmtree(tmp_dir, ignore_errors=True) diff --git a/leapp/backends/tensorrt_onnx_graph_split.py b/leapp/backends/tensorrt_onnx_graph_split.py new file mode 100644 index 00000000..f15ba476 --- /dev/null +++ b/leapp/backends/tensorrt_onnx_graph_split.py @@ -0,0 +1,428 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Split ONNX graphs into TensorRT-supported and unsupported segments. + +Provides catalog-based partitioning (no TensorRT install required) plus helpers +to extract and save contiguous subgraphs. Optionally uses TensorRT's ONNX +parser ``supports_model`` API when ``tensorrt`` is installed, similar to +``polygraphy inspect capability --with-partitioning``. + +For insert / remove / swap / rename / subgraph-replace edits (GraphSurgeon), +see ``isaac_deploy_trt.surgery``. To rewrite an ONNX layer as a TensorRT +plugin node, see ``leapp.backends.tensorrt_plugin_replace``. +""" + +from __future__ import annotations + +import os +from dataclasses import dataclass, field +from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple + +import onnx +from onnx import ModelProto, TensorProto, ValueInfoProto, helper + +from leapp.utils.logging import _get_logger + + +@dataclass(frozen=True) +class NodeSegment: + """Inclusive-start / exclusive-end node index range in topological order.""" + + start: int + end: int + supported: bool + ops: Tuple[str, ...] = () + + @property + def num_nodes(self) -> int: + return self.end - self.start + + +@dataclass +class GraphSplitResult: + """Result of partitioning an ONNX model for TensorRT.""" + + onnx_path: Optional[str] + segments: List[NodeSegment] = field(default_factory=list) + supported_paths: List[str] = field(default_factory=list) + unsupported_paths: List[str] = field(default_factory=list) + errors: List[str] = field(default_factory=list) + + @property + def fully_supported(self) -> bool: + return bool(self.segments) and all(seg.supported for seg in self.segments) + + @property + def supported_segments(self) -> List[NodeSegment]: + return [seg for seg in self.segments if seg.supported] + + @property + def unsupported_segments(self) -> List[NodeSegment]: + return [seg for seg in self.segments if not seg.supported] + + +def is_op_tensorrt_supported( + op_type: str, + *, + known_supported: Optional[Set[str]] = None, + unknown_as_supported: bool = False, +) -> bool: + """Return whether an ONNX op is treated as TensorRT-supported. + + Args: + op_type: ONNX operator type name. + known_supported: Optional override set of supported op names. + unknown_as_supported: If True, ops absent from the catalog are treated + as supported. Default False (safer for TRT subgraph extraction). + """ + from isaac_deploy_trt.tensorrt_onnx_ops import ( + TENSORRT_ONNX_OPS, + supported_onnx_ops, + ) + + supported = known_supported if known_supported is not None else supported_onnx_ops() + if op_type in supported: + return True + if op_type in TENSORRT_ONNX_OPS: + return False + return unknown_as_supported + + +def partition_nodes_by_tensorrt_support( + nodes: Sequence, + *, + known_supported: Optional[Set[str]] = None, + unknown_as_supported: bool = False, +) -> List[NodeSegment]: + """Partition a node list into contiguous supported/unsupported segments. + + Consecutive nodes with the same support flag are merged into one segment. + """ + if not nodes: + return [] + + segments: List[NodeSegment] = [] + start = 0 + current_supported = is_op_tensorrt_supported( + nodes[0].op_type, + known_supported=known_supported, + unknown_as_supported=unknown_as_supported, + ) + current_ops: List[str] = [nodes[0].op_type] + + for idx in range(1, len(nodes)): + supported = is_op_tensorrt_supported( + nodes[idx].op_type, + known_supported=known_supported, + unknown_as_supported=unknown_as_supported, + ) + if supported == current_supported: + current_ops.append(nodes[idx].op_type) + continue + segments.append( + NodeSegment( + start=start, + end=idx, + supported=current_supported, + ops=tuple(current_ops), + ) + ) + start = idx + current_supported = supported + current_ops = [nodes[idx].op_type] + + segments.append( + NodeSegment( + start=start, + end=len(nodes), + supported=current_supported, + ops=tuple(current_ops), + ) + ) + return segments + + +def _value_info_map(model: ModelProto) -> Dict[str, ValueInfoProto]: + mapping: Dict[str, ValueInfoProto] = {} + for vi in list(model.graph.input) + list(model.graph.output) + list(model.graph.value_info): + mapping[vi.name] = vi + return mapping + + +def _initializer_names(model: ModelProto) -> Set[str]: + return {init.name for init in model.graph.initializer} + + +def _make_value_info(name: str, existing: Optional[ValueInfoProto] = None) -> ValueInfoProto: + if existing is not None and existing.name == name: + return existing + # Fallback when shape/type metadata is unavailable. + return helper.make_tensor_value_info(name, TensorProto.FLOAT, None) + + +def extract_onnx_subgraph( + model: ModelProto, + start: int, + end: int, + *, + graph_name: Optional[str] = None, +) -> ModelProto: + """Extract ``model.graph.node[start:end]`` into a standalone ONNX model. + + Graph inputs are tensors consumed by the segment that are not produced + inside it (excluding initializers). Graph outputs are tensors produced by + the segment that are not consumed inside it, plus any original model + outputs produced by the segment. + """ + if start < 0 or end > len(model.graph.node) or start >= end: + raise ValueError( + f"Invalid node range [{start}, {end}) for graph with " + f"{len(model.graph.node)} nodes" + ) + + nodes = list(model.graph.node[start:end]) + produced: Set[str] = {out for node in nodes for out in node.output if out} + consumed: Set[str] = {inp for node in nodes for inp in node.input if inp} + initializer_names = _initializer_names(model) + original_outputs = {out.name for out in model.graph.output} + + input_names = sorted(name for name in consumed if name not in produced and name not in initializer_names) + # Prefer tensors that escape the segment; always keep original graph outputs. + internal_consumed = consumed & produced + output_names = sorted( + (produced - internal_consumed) | (produced & original_outputs) + ) + if not output_names: + # Degenerate segment that only feeds initializers-style sinks: expose + # all produced tensors so the subgraph remains runnable. + output_names = sorted(produced) + + vi_map = _value_info_map(model) + graph_inputs = [_make_value_info(name, vi_map.get(name)) for name in input_names] + graph_outputs = [_make_value_info(name, vi_map.get(name)) for name in output_names] + + used_initializers = [ + init for init in model.graph.initializer if init.name in consumed + ] + value_infos = [ + vi_map[name] + for name in sorted(produced & set(vi_map) - set(input_names) - set(output_names)) + ] + + subgraph = helper.make_graph( + nodes=nodes, + name=graph_name or f"subgraph_nodes_{start}_{end - 1}", + inputs=graph_inputs, + outputs=graph_outputs, + initializer=used_initializers, + value_info=value_infos, + ) + + opset_imports = list(model.opset_import) or [helper.make_opsetid("", 17)] + return helper.make_model(subgraph, opset_imports=opset_imports, ir_version=model.ir_version) + + +def save_segment_subgraphs( + model: ModelProto, + segments: Sequence[NodeSegment], + output_dir: str, + *, + prefix: str = "", + only_supported: Optional[bool] = None, +) -> Tuple[List[str], List[str]]: + """Save segment subgraphs under ``output_dir``. + + Args: + model: Parent ONNX model. + segments: Partition segments. + output_dir: Directory for written ``.onnx`` files. + prefix: Optional filename prefix. + only_supported: If True/False, only write that class of segments. + ``None`` writes both. + + Returns: + ``(supported_paths, unsupported_paths)`` + """ + os.makedirs(output_dir, exist_ok=True) + supported_paths: List[str] = [] + unsupported_paths: List[str] = [] + + for seg in segments: + if only_supported is True and not seg.supported: + continue + if only_supported is False and seg.supported: + continue + + kind = "supported" if seg.supported else "unsupported" + filename = f"{prefix}{kind}_subgraph-nodes-{seg.start}-{seg.end - 1}.onnx" + path = os.path.join(output_dir, filename) + submodel = extract_onnx_subgraph( + model, + seg.start, + seg.end, + graph_name=f"{kind}_nodes_{seg.start}_{seg.end - 1}", + ) + onnx.save(submodel, path) + if seg.supported: + supported_paths.append(path) + else: + unsupported_paths.append(path) + + return supported_paths, unsupported_paths + + +def split_onnx_by_tensorrt_support( + onnx_path: str, + *, + output_dir: Optional[str] = None, + known_supported: Optional[Iterable[str]] = None, + unknown_as_supported: bool = False, + save: bool = True, +) -> GraphSplitResult: + """Split an ONNX model using the static TensorRT op catalog. + + This does not require the ``tensorrt`` Python package. Segments are formed + from contiguous runs of supported vs unsupported/unknown nodes. + """ + model = onnx.load(onnx_path, load_external_data=False) + supported_set = set(known_supported) if known_supported is not None else None + segments = partition_nodes_by_tensorrt_support( + model.graph.node, + known_supported=supported_set, + unknown_as_supported=unknown_as_supported, + ) + + result = GraphSplitResult(onnx_path=onnx_path, segments=segments) + if not save: + return result + + out_dir = output_dir or os.path.join( + os.path.dirname(os.path.abspath(onnx_path)) or ".", + "tensorrt_graph_split", + ) + supported_paths, unsupported_paths = save_segment_subgraphs( + model, segments, out_dir + ) + result.supported_paths = supported_paths + result.unsupported_paths = unsupported_paths + + logger = _get_logger() + logger.info( + f"Split {onnx_path} into {len(segments)} segment(s) " + f"({len(result.supported_segments)} supported, " + f"{len(result.unsupported_segments)} unsupported) under {out_dir}" + ) + return result + + +def split_onnx_with_tensorrt_parser( + onnx_path: str, + *, + output_dir: Optional[str] = None, + save: bool = True, +) -> GraphSplitResult: + """Split an ONNX model using TensorRT ``OnnxParser.supports_model``. + + Requires the ``tensorrt`` package. Falls back to reporting an error in + ``GraphSplitResult.errors`` when TensorRT is unavailable or the API is + missing. + """ + result = GraphSplitResult(onnx_path=onnx_path) + try: + import tensorrt as trt + except ImportError as exc: + result.errors.append( + "tensorrt is not installed; cannot run parser-based graph split" + ) + result.errors.append(str(exc)) + return result + + if not hasattr(trt.OnnxParser, "supports_model"): + result.errors.append( + "tensorrt.OnnxParser.supports_model is unavailable in this TensorRT version" + ) + return result + + logger = trt.Logger(trt.Logger.WARNING) + builder = trt.Builder(logger) + network_flags = 1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH) + network = builder.create_network(network_flags) + parser = trt.OnnxParser(network, logger) + + with open(onnx_path, "rb") as f: + model_bytes = f.read() + fully_supported, nodelists = parser.supports_model(model_bytes, onnx_path) + + model = onnx.load(onnx_path, load_external_data=False) + segments: List[NodeSegment] = [] + for node_indices, supported in nodelists: + if not node_indices: + continue + start = int(node_indices[0]) + end = int(node_indices[-1]) + 1 + ops = tuple(model.graph.node[i].op_type for i in range(start, end)) + segments.append( + NodeSegment(start=start, end=end, supported=bool(supported), ops=ops) + ) + + # If TRT reports full support but returns no partitions, treat the whole + # graph as one supported segment. + if fully_supported and not segments and model.graph.node: + segments = [ + NodeSegment( + start=0, + end=len(model.graph.node), + supported=True, + ops=tuple(node.op_type for node in model.graph.node), + ) + ] + + result.segments = segments + if not save: + return result + + out_dir = output_dir or os.path.join( + os.path.dirname(os.path.abspath(onnx_path)) or ".", + "tensorrt_graph_split_parser", + ) + supported_paths, unsupported_paths = save_segment_subgraphs( + model, segments, out_dir + ) + result.supported_paths = supported_paths + result.unsupported_paths = unsupported_paths + return result + + +def replace_unsupported_nodes_with_identity( + model: ModelProto, + *, + known_supported: Optional[Set[str]] = None, + unknown_as_supported: bool = False, +) -> ModelProto: + """Return a copy where unsupported single-input/single-output nodes become Identity. + + Useful as a coarse placeholder when prototyping TRT-only paths. Nodes that + are not 1-in/1-out are left unchanged and should be handled by subgraph + extraction instead. + """ + cloned = ModelProto() + cloned.CopyFrom(model) + supported_set = known_supported + + for node in cloned.graph.node: + if is_op_tensorrt_supported( + node.op_type, + known_supported=supported_set, + unknown_as_supported=unknown_as_supported, + ): + continue + if len(node.input) != 1 or len(node.output) != 1: + continue + del node.attribute[:] + node.op_type = "Identity" + node.name = f"{node.name}_as_identity" if node.name else "unsupported_as_identity" + + return cloned diff --git a/leapp/backends/tensorrt_plugin_replace.py b/leapp/backends/tensorrt_plugin_replace.py new file mode 100644 index 00000000..925129fd --- /dev/null +++ b/leapp/backends/tensorrt_plugin_replace.py @@ -0,0 +1,257 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Replace ONNX layers / subgraphs with TensorRT plugin nodes. + +TensorRT's ONNX parser looks up a registered plugin creator whose name matches +the ONNX node ``op_type``. These helpers rewrite the graph (via GraphSurgeon) +so a standard ONNX layer or tensor-bounded subgraph becomes that plugin node. + +Requires ``isaac_deploy_trt`` (``pip install -e ./packages/isaac_deploy_trt``). + +Example:: + + from leapp.backends.tensorrt_plugin_replace import ( + TrtPluginSpec, + replace_onnx_layer_with_trt_plugin, + ) + + replace_onnx_layer_with_trt_plugin( + "model.onnx", + layer_name="nms", + plugin=TrtPluginSpec( + name="BatchedNMS_TRT", + attrs={"shareLocation": 1, "numClasses": 80}, + version="1", + namespace="", + ), + output_path="model_trt_plugin.onnx", + ) +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional, Sequence, Union + +from onnx import ModelProto + +from leapp.utils.logging import _get_logger + +GraphLike = Any +NodeLike = Any +TensorLike = Any + + +def _ogs(): + try: + from isaac_deploy_trt import surgery as ogs + except ImportError as exc: + raise ImportError( + "isaac_deploy_trt is required for TensorRT plugin replacement. " + "Install with: pip install -e ./packages/isaac_deploy_trt" + ) from exc + return ogs + + +@dataclass +class TrtPluginSpec: + """Description of a TensorRT plugin node to insert into ONNX. + + Attributes: + name: Plugin / creator name. Written as the ONNX ``op_type``. + attrs: Plugin attributes stored as ONNX node attributes. + version: Optional plugin version; stored as ``plugin_version`` unless + already present in ``attrs``. + namespace: Optional plugin namespace; stored as ``plugin_namespace`` + unless already present in ``attrs``. + node_name: Optional ONNX node name for the replacement node. + """ + + name: str + attrs: Dict[str, Any] = field(default_factory=dict) + version: Optional[str] = None + namespace: Optional[str] = None + node_name: Optional[str] = None + + def onnx_attrs(self) -> Dict[str, Any]: + """Attrs dict written onto the ONNX plugin node.""" + attrs = dict(self.attrs) + if self.version is not None: + attrs.setdefault("plugin_version", self.version) + if self.namespace is not None: + attrs.setdefault("plugin_namespace", self.namespace) + return attrs + + +def _normalize_plugin(plugin: Union[str, TrtPluginSpec]) -> TrtPluginSpec: + if isinstance(plugin, TrtPluginSpec): + return plugin + return TrtPluginSpec(name=plugin) + + +def replace_layer_with_trt_plugin( + graph: GraphLike, + layer_name: str, + plugin: Union[str, TrtPluginSpec], + *, + keep_node_name: bool = True, +) -> NodeLike: + """Replace one ONNX layer (by node name) with a TRT plugin node in-place. + + Keeps the same input/output tensors; only ``op_type``, attrs, and optionally + the node name change. + """ + spec = _normalize_plugin(plugin) + new_name = spec.node_name + if new_name is None and keep_node_name: + new_name = None # leave existing name + elif new_name is None and not keep_node_name: + new_name = f"{layer_name}_{spec.name}" + + node = _ogs().replace_node_with_plugin( + graph, + layer_name, + spec.name, + attrs=spec.onnx_attrs(), + new_name=new_name, + ) + _get_logger().info( + f"Replaced ONNX layer {layer_name!r} with TRT plugin {spec.name!r}" + ) + return node + + +def replace_layers_by_op_with_trt_plugin( + graph: GraphLike, + onnx_op: str, + plugin: Union[str, TrtPluginSpec], + *, + predicate=None, +) -> List[NodeLike]: + """Replace every node with ONNX op ``onnx_op`` with the same TRT plugin. + + Args: + graph: GraphSurgeon graph. + onnx_op: Source ONNX operator type (e.g. ``"NonMaxSuppression"``). + plugin: Target plugin spec or plugin name string. + predicate: Optional ``callable(node) -> bool`` to filter matches. + + Returns: + List of replaced plugin nodes. + """ + spec = _normalize_plugin(plugin) + matches = _ogs().find_nodes(graph, op=onnx_op, predicate=predicate) + replaced: List[NodeLike] = [] + for node in matches: + # Names can be empty; fall back to object identity via current name + # after ensuring a stable name for lookup. + if not node.name: + node.name = f"{onnx_op}_{len(replaced)}" + replaced.append( + replace_layer_with_trt_plugin(graph, node.name, spec, keep_node_name=True) + ) + _get_logger().info( + f"Replaced {len(replaced)} ONNX '{onnx_op}' layer(s) with TRT plugin {spec.name!r}" + ) + return replaced + + +def replace_subgraph_with_trt_plugin( + graph: GraphLike, + inputs: Sequence[Union[str, TensorLike]], + outputs: Sequence[Union[str, TensorLike]], + plugin: Union[str, TrtPluginSpec], + *, + cleanup: bool = True, +) -> NodeLike: + """Replace the subgraph between ``inputs`` and ``outputs`` with one TRT plugin. + + This is the GraphSurgeon TRT-plugin pattern: disconnect the span, insert a + plugin node with those I/O tensors, then cleanup dangling nodes. + """ + spec = _normalize_plugin(plugin) + node = _ogs().replace_subgraph( + graph, + inputs=inputs, + outputs=outputs, + op=spec.name, + attrs=spec.onnx_attrs(), + name=spec.node_name or "", + ) + if cleanup: + _ogs().cleanup_graph(graph) + _get_logger().info( + f"Replaced subgraph with TRT plugin {spec.name!r} " + f"(inputs={list(inputs)}, outputs={list(outputs)})" + ) + return node + + +def replace_onnx_layer_with_trt_plugin( + model_or_path: Union[str, ModelProto], + plugin: Union[str, TrtPluginSpec], + *, + layer_name: Optional[str] = None, + onnx_op: Optional[str] = None, + input_tensors: Optional[Sequence[str]] = None, + output_tensors: Optional[Sequence[str]] = None, + output_path: Optional[str] = None, +) -> ModelProto: + """High-level helper: load ONNX, replace layer(s)/subgraph with a TRT plugin. + + Exactly one replacement mode must be selected: + + - ``layer_name``: replace a single named node in-place. + - ``onnx_op``: replace all nodes of that ONNX op type. + - ``input_tensors`` + ``output_tensors``: replace that subgraph span. + + Args: + model_or_path: ONNX path or ``ModelProto``. + plugin: Plugin name or :class:`TrtPluginSpec`. + layer_name: Node name to replace. + onnx_op: Op type to replace everywhere. + input_tensors: Subgraph input tensor names. + output_tensors: Subgraph output tensor names. + output_path: If set, write the modified model here. + + Returns: + Modified ``ModelProto``. + """ + modes = ( + int(layer_name is not None) + + int(onnx_op is not None) + + int(input_tensors is not None or output_tensors is not None) + ) + if modes != 1: + raise ValueError( + "Specify exactly one of: layer_name, onnx_op, " + "or input_tensors+output_tensors" + ) + if (input_tensors is None) ^ (output_tensors is None): + raise ValueError("input_tensors and output_tensors must be provided together") + + graph = _ogs().load_graph(model_or_path) + spec = _normalize_plugin(plugin) + + if layer_name is not None: + replace_layer_with_trt_plugin(graph, layer_name, spec) + elif onnx_op is not None: + replaced = replace_layers_by_op_with_trt_plugin(graph, onnx_op, spec) + if not replaced: + raise KeyError(f"No ONNX layers with op_type {onnx_op!r} found") + else: + assert input_tensors is not None and output_tensors is not None + replace_subgraph_with_trt_plugin( + graph, input_tensors, output_tensors, spec, cleanup=True + ) + + model = _ogs().export_model(graph, do_cleanup=True) + if output_path is not None: + import onnx + + onnx.save(model, output_path) + _get_logger().info(f"Wrote TRT-plugin ONNX to {output_path}") + return model diff --git a/leapp/cli.py b/leapp/cli.py new file mode 100644 index 00000000..b1e4995b --- /dev/null +++ b/leapp/cli.py @@ -0,0 +1,40 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""LEAPP command-line entry point. + +TensorRT ONNX rewrite, catalog check, and pipeline merge live in the sibling +``isaac_deploy_trt`` package:: + + pip install -e ./packages/isaac_deploy_trt + isaac_deploy_trt check --onnx model.onnx --strict + isaac_deploy_trt check --onnx-dir ./exported_graph --build --strict + isaac_deploy_trt rewrite-dir ./exported_graph -o ./exported_graph_trt + isaac_deploy_trt merge-pipeline exported.yaml -o pipeline.onnx --rewrite +""" + +from __future__ import annotations + +import sys +from typing import Optional, Sequence + +_MOVED = """TensorRT ONNX tools moved to isaac_deploy_trt. + + pip install -e ./packages/isaac_deploy_trt + isaac_deploy_trt check --onnx MODEL.onnx [--build] [--strict] + isaac_deploy_trt check --onnx-dir EXPORT_DIR [--build] [--strict] + isaac_deploy_trt rewrite-dir INPUT_DIR -o OUTPUT_DIR + isaac_deploy_trt merge-pipeline EXPORTED.yaml -o pipeline.onnx [--rewrite] +""" + + +def main(argv: Optional[Sequence[str]] = None) -> int: + print(_MOVED, file=sys.stderr) + _ = argv + return 2 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/leapp/leapp.py b/leapp/leapp.py index 88769edf..d834cba6 100644 --- a/leapp/leapp.py +++ b/leapp/leapp.py @@ -201,6 +201,76 @@ def compile_graph(visualize=True, verbose=None, validate=True, return True +def optimize_graph(trt_compatible=False): + """Post-compile optimizations for the saved LEAPP graph. + + Call after ``compile_graph()``. Options can be combined as more passes are + added; today ``trt_compatible`` is the TensorRT ONNX rewrite pass. + + When ``trt_compatible=True``, LEAPP rewrites exported ONNX files in the + graph output directory so TensorRT can parse them (UINT8 intermediate + Casts, Resize ``antialias``, rank-9 Reshape) and updates YAML checksums + plus ``parameters.tensorrt_compatible``. Graph input/output names, dtypes, + and shapes are left unchanged. Requires ``isaac_deploy_trt``. + """ + manager = _MANAGER + + if ExportManager.is_interpret_graph_enabled(): + _get_logger().fatal( + "LEAPP graph interpretation is enabled. Call leapp.stop() and " + "leapp.compile_graph() before leapp.optimize_graph().", + error_type=Exception) + + save_path = manager.get_save_path() + if not save_path or not os.path.isdir(save_path): + _get_logger().fatal( + "leapp.optimize_graph() requires a compiled graph directory. " + "Call leapp.compile_graph() first.", + error_type=Exception) + + yaml_path = os.path.join(save_path, f"{manager.get_graph_name()}.yaml") + if not os.path.isfile(yaml_path): + _get_logger().fatal( + f"leapp.optimize_graph() did not find {yaml_path}. " + "Call leapp.compile_graph() first.", + error_type=Exception) + + applied = {} + + if trt_compatible: + try: + from leapp.backends.tensorrt_leapp_bundle import ( + rewrite_leapp_export_for_tensorrt, + ) + except ImportError as exc: + _get_logger().fatal( + "optimize_graph(trt_compatible=True) requires isaac_deploy_trt. " + "Install with: pip install -e ./packages/isaac_deploy_trt", + error_type=ImportError, + cause=exc, + ) + _get_logger().section("Graph optimization: trt_compatible") + result = rewrite_leapp_export_for_tensorrt(save_path) + rewritten = [model.filename for model in result.models if model.rewritten] + if rewritten: + _get_logger().info( + f"Rewrote ONNX for TensorRT: {', '.join(rewritten)}" + ) + else: + _get_logger().info( + "No TensorRT GraphSurgeon rewrites were needed for exported ONNX" + ) + applied["trt_compatible"] = result + + if not applied: + _get_logger().warning( + "leapp.optimize_graph() ran with no optimization options enabled. " + "Pass trt_compatible=True to rewrite ONNX for TensorRT." + ) + + return applied + + class AnnotateAPI: """Annotation-only facade over ExportManager.""" diff --git a/packages/isaac_deploy_trt/.gitignore b/packages/isaac_deploy_trt/.gitignore new file mode 100644 index 00000000..6b000a9a --- /dev/null +++ b/packages/isaac_deploy_trt/.gitignore @@ -0,0 +1,12 @@ +.venv/ +__pycache__/ +*.pyc +*.egg-info/ +.pytest_cache/ +dist/ +build/ +*.onnx +*.onnx.data +*.plan +.env +.env.* diff --git a/packages/isaac_deploy_trt/LICENSE b/packages/isaac_deploy_trt/LICENSE new file mode 100644 index 00000000..7a774156 --- /dev/null +++ b/packages/isaac_deploy_trt/LICENSE @@ -0,0 +1,176 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, +and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by +the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all +other entities that control, are controlled by, or are under common +control with that entity. For the purposes of this definition, +"control" means (i) the power, direct or indirect, to cause the +direction or management of such entity, whether by contract or +otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity +exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, +including but not limited to software source code, documentation +source, and configuration files. + +"Object" form shall mean any form resulting from mechanical +transformation or translation of a Source form, including but +not limited to compiled object code, generated documentation, +and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or +Object form, made available under the License, as indicated by a +copyright notice that is included in or attached to the work +(an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object +form, that is based on (or derived from) the Work and for which the +editorial revisions, annotations, elaborations, or other modifications +represent, as a whole, an original work of authorship. For the purposes +of this License, Derivative Works shall not include works that remain +separable from, or merely link (or bind by name) to the interfaces of, +the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including +the original version of the Work and any modifications or additions +to that Work or Derivative Works thereof, that is intentionally +submitted to Licensor for inclusion in the Work by the copyright owner +or by an individual or Legal Entity authorized to submit on behalf of +the copyright owner. For the purposes of this definition, "submitted" +means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, +and issue tracking systems that are managed by, or on behalf of, the +Licensor for the purpose of discussing and improving the Work, but +excluding communication that is conspicuously marked or otherwise +designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity +on behalf of whom a Contribution has been received by Licensor and +subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the +Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +(except as stated in this section) patent license to make, have made, +use, offer to sell, sell, import, and otherwise transfer the Work, +where such license applies only to those patent claims licensable +by such Contributor that are necessarily infringed by their +Contribution(s) alone or by combination of their Contribution(s) +with the Work to which such Contribution(s) was submitted. If You +institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work +or a Contribution incorporated within the Work constitutes direct +or contributory patent infringement, then any patent licenses +granted to You under this License for that Work shall terminate +as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the +Work or Derivative Works thereof in any medium, with or without +modifications, and in Source or Object form, provided that You +meet the following conditions: + +(a) You must give any other recipients of the Work or +Derivative Works a copy of this License; and + +(b) You must cause any modified files to carry prominent notices +stating that You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works +that You distribute, all copyright, patent, trademark, and +attribution notices from the Source form of the Work, +excluding those notices that do not pertain to any part of +the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its +distribution, then any Derivative Works that You distribute must +include a readable copy of the attribution notices contained +within such NOTICE file, excluding those notices that do not +pertain to any part of the Derivative Works, in at least one +of the following places: within a NOTICE text file distributed +as part of the Derivative Works; within the Source form or +documentation, if provided along with the Derivative Works; or, +within a display generated by the Derivative Works, if and +wherever such third-party notices normally appear. The contents +of the NOTICE file are for informational purposes only and +do not modify the License. You may add Your own attribution +notices within Derivative Works that You distribute, alongside +or as an addendum to the NOTICE text from the Work, provided +that such additional attribution notices cannot be construed +as modifying the License. + +You may add Your own copyright statement to Your modifications and +may provide additional or different license terms and conditions +for use, reproduction, or distribution of Your modifications, or +for any such Derivative Works as a whole, provided Your use, +reproduction, and distribution of the Work otherwise complies with +the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, +any Contribution intentionally submitted for inclusion in the Work +by You to the Licensor shall be under the terms and conditions of +this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify +the terms of any separate license agreement you may have executed +with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade +names, trademarks, service marks, or product names of the Licensor, +except as required for reasonable and customary use in describing the +origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or +agreed to in writing, Licensor provides the Work (and each +Contributor provides its Contributions) on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied, including, without limitation, any warranties or conditions +of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A +PARTICULAR PURPOSE. You are solely responsible for determining the +appropriateness of using or redistributing the Work and assume any +risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, +whether in tort (including negligence), contract, or otherwise, +unless required by applicable law (such as deliberate and grossly +negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, +incidental, or consequential damages of any character arising as a +result of this License or out of the use or inability to use the +Work (including but not limited to damages for loss of goodwill, +work stoppage, computer failure or malfunction, or any and all +other commercial damages or losses), even if such Contributor +has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing +the Work or Derivative Works thereof, You may choose to offer, +and charge a fee for, acceptance of support, warranty, indemnity, +or other liability obligations and/or rights consistent with this +License. However, in accepting such obligations, You may act only +on Your own behalf and on Your sole responsibility, not on behalf +of any other Contributor, and only if You agree to indemnify, +defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason +of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/packages/isaac_deploy_trt/README.md b/packages/isaac_deploy_trt/README.md new file mode 100644 index 00000000..5172c34c --- /dev/null +++ b/packages/isaac_deploy_trt/README.md @@ -0,0 +1,241 @@ +# isaac_deploy_trt + +Standalone GraphSurgeon toolkit that applies the same TensorRT ONNX rewrites +used in LEAPP, without depending on LEAPP export/tracing. + +Given an ONNX file (or a directory of them), it: + +1. Detects TensorRT-hostile patterns +2. Rewrites them in-graph +3. **Keeps graph input/output names, dtypes, and shapes** so Triton / DAG + bindings do not need renaming + +This repo **does not download models**. Point the CLI at ONNX you already have +(for GR00T Apple PnP, that is typically a Hugging Face LEAPP export dir). + +It does **not** freeze GR00T backbone grid tensors or build `.plan` files. +Use ``merge-pipeline`` (below) to inline a LEAPP DAG for one Isaac +``TensorRTNode``. That is not a substitute for ``trtexec``. + +## Rewrites (same as LEAPP) + +| Pattern | Change | +|---|---| +| Intermediate `Cast` to UINT8 | Cast to INT32 instead | +| `Resize` with `antialias != 0` | Set `antialias=0` | +| `Reshape` to rank > 8 | Drop extent-1 axes; remap following `Transpose` perms | + +Graphs without those patterns are **copied** (plus `.onnx.data` sidecars). Output +must be a different path than the input. + +This tree lives under `packages/isaac_deploy_trt`, parallel to +`packages/leapp-visualization`. It keeps its own `pyproject.toml` so it can be +installed on its own; LEAPP still imports it as `isaac_deploy_trt`. + +## Install + +From the LEAPP repository root: + +```bash +pip install -e ./packages/isaac_deploy_trt +# or with tests: +pip install -e "./packages/isaac_deploy_trt[dev]" +``` + +--- + +## Commands + +### Rewrite one file + +```bash +isaac_deploy_trt rewrite IN.onnx -o OUT.onnx +``` + +Example (the only Apple PnP node that currently needs surgery): + +```bash +isaac_deploy_trt rewrite \ + /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx/preprocess_video.onnx \ + -o /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx_surgeon/preprocess_video.onnx +``` + +### Rewrite a directory into another folder + +Copies every `*.onnx` (and matching `.onnx.data`) into `-o`. Only graphs that +hit the three patterns above are edited. + +`-o` **must not** be the input directory. + +```bash +isaac_deploy_trt rewrite-dir INPUT_DIR -o OUTPUT_DIR +``` + +GR00T Apple PnP LEAPP pack: + +```bash +isaac_deploy_trt rewrite-dir \ + /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx \ + -o /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx_surgeon +``` + +For `nvidia/GR00T-N1.7-ApplePnP-V1` as exported today: + +| File | Surgeon | +|---|---| +| `preprocess_video.onnx` | rewrite (UINT8 Cast, Resize antialias, rank-9 Reshape) | +| `preprocess_state.onnx` | copy | +| `backbone.onnx` | copy | +| `action_head.onnx` | copy | +| `decode_action.onnx` | copy | + +YAML (`exported_leapp.yaml`) is **not** copied by `rewrite-dir`. Copy it +yourself if you need a full deploy tree. + +### Catalog-check ONNX (validate) + +Static check: ops in the graph vs the baked-in TensorRT `operators.md` table. +Does **not** rewrite files. Does **not** load `tensorrt_catalogs/*.json`. + +Does **not** catch UINT8 Cast / Resize antialias / rank-9 Reshape. Those only +show up with TensorRT parse (`--build`) or `trtexec`. + +```bash +# one file +isaac_deploy_trt check --onnx PATH.onnx + +# every .onnx in a folder +isaac_deploy_trt check --onnx-dir DIR + +# exit 1 if any file fails the catalog check +isaac_deploy_trt check --onnx-dir DIR --strict + +# also TensorRT parse/build (needs TensorRT installed) +isaac_deploy_trt check --onnx-dir DIR --build +``` + +Examples: + +```bash +isaac_deploy_trt check --onnx-dir \ + /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx + +isaac_deploy_trt check --onnx-dir \ + /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx_surgeon \ + --strict +``` + +### Merge a LEAPP DAG into one ONNX file (TensorRTNode, no Triton) + +Isaac ROS ``TensorRTNode`` loads a **single** engine. LEAPP export is still +one ONNX per node. This inlines ``pipeline.data_flow`` (fan-out included) into +one graph. ``feedback_flow`` tensors stay as extra I/O (previous tick). +Colliding input/output names rename the input to ``_in_``. + +Weights stay external; ``.onnx.data`` files are **symlinked** next to the +merged protobuf (does not load the 6 GB GR00T backbone into RAM). + +```bash +isaac_deploy_trt merge-pipeline EXPORTED.yaml -o pipeline.onnx +``` + +``--rewrite`` applies the GraphSurgeon TensorRT edits to each subgraph before +merge (needed if you have not already run ``rewrite-dir``). + +``--model-dir`` defaults to the YAML directory. ``--yaml-out`` overrides the +sibling ``pipeline.yaml`` (TensorRTNode ``input_tensor_names`` / +``output_tensor_names``). + +Standalone script (same flags after the YAML path): + +```bash +python scripts/merge_pipeline.py EXPORTED.yaml -o pipeline.onnx --rewrite +``` + +GR00T Apple PnP (rewritten video preprocess + merge): + +```bash +isaac_deploy_trt merge-pipeline \ + /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx/exported_leapp.yaml \ + --model-dir /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx \ + -o /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_pipeline/pipeline.onnx \ + --rewrite +``` + +Then build the engine on the target GPU: + +```bash +trtexec \ + --onnx=/mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_pipeline/pipeline.onnx \ + --saveEngine=/mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_pipeline/pipeline.plan \ + --fp16 --memPoolSize=workspace:8192 --skipInference +``` + +Pass ``engine_file_path`` plus the name lists from ``pipeline.yaml`` into +``TensorRTNode``. This path is Triton-free. + +Prefer a **frozen-grid** backbone export if TensorRT classifies +``image_grid_thw`` as a shape tensor (Triton TRT backend also rejects that; +``TensorRTNode`` is different, but freezing still avoids a bad binding). + +Do not run this merge on a small machine if you intend to *inline* every +weight into one file; this implementation does not do that. ``trtexec`` on +the full GR00T DAG still needs a large workspace. + +### Join operators.md + headers (one JSON) + +```bash +isaac_deploy_trt catalog --operators-md operators.md \ + --releases v11.2,v11.1 -o trt_catalog.json +``` + +### Generate per-release / per-platform catalogs + +Writes JSON and Markdown under `-o` (default formats: `json,md`). Use +`--format json` for JSON only. Platform overlays are **not** a live GPU query. + +Default platforms are Isaac Debian pockets: + +| Key | Isaac dist | Hardware | +|---|---|---| +| `noble` | `noble` | Ubuntu 24.04 amd64 dGPU (same overlay as `x86`) | +| `noble-fastos` | `noble-fastos` | DGX Spark / FastOS ARM (not JetPack) | +| `noble-jetpack` | `noble-jetpack` | Jetson Orin + Thor / JetPack 7.2, TensorRT 10.16 | + +SKU overlays `x86`, `orin`, `thor`, `dgx` still work (`orin` is Orin-accurate; +`noble-jetpack` is the union pocket and keeps Thor dtypes). Aliases: `amd64` → +`noble`, `spark` → `noble-fastos`, `jetson`/`jp7` → `noble-jetpack`. + +```bash +isaac_deploy_trt generate -o tensorrt_catalogs --print-summary \ + --platforms noble,noble-fastos,noble-jetpack \ + --releases v10.7.0,v10.8.0,v10.9.0,v10.10.0,v10.11,v10.12.0,v10.13.0,v10.13.2,v10.13.3,v10.14,v10.15,v10.16,v11.0,v11.1,v11.2 +``` + +Checked-in databases live in [`tensorrt_catalogs/`](tensorrt_catalogs/index.json). +Look up a GitHub tag in `release_to_database`, then open that directory. + +There are no public `v11.3` / `v11.4` tags. Latest OSS 11.x tags are `v11.0`, +`v11.1`, `v11.2`. + +--- + +## Python + +```python +from isaac_deploy_trt import rewrite_onnx_file, rewrite_directory + +rewrite_onnx_file("preprocess_video.onnx", "preprocess_video_trt.onnx") +rewrite_directory("in_dir", "out_dir") +``` + +## What this is not + +- Not a Hugging Face downloader (source ONNX stays in the export dir) +- Not a substitute for `trtexec` (always build-check on the target GPU) +- Not Isaac ROS / Triton launch (`merge-pipeline` only writes ONNX + YAML) + +## Origin + +Logic ported from NVIDIA LEAPP (`leapp.backends.onnx_graph_surgery` / +`align_leapp_export_for_tensorrt`), Apache-2.0. diff --git a/packages/isaac_deploy_trt/pyproject.toml b/packages/isaac_deploy_trt/pyproject.toml new file mode 100644 index 00000000..967d3bd7 --- /dev/null +++ b/packages/isaac_deploy_trt/pyproject.toml @@ -0,0 +1,31 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "isaac_deploy_trt" +version = "0.1.0" +description = "GraphSurgeon ONNX rewrites to make models TensorRT-parseable" +readme = "README.md" +license = "Apache-2.0" +requires-python = ">=3.10" +dependencies = [ + "onnx>=1.16.0", + "onnx-graphsurgeon>=0.5.0", + "numpy>=1.24.0", + "pyyaml>=6.0", +] + +[project.optional-dependencies] +dev = ["pytest"] +ort = ["onnxruntime>=1.20.0"] + +[project.scripts] +isaac_deploy_trt = "isaac_deploy_trt.cli:main" +generate-tensorrt-supported-layers = "isaac_deploy_trt.generate_cmd:main" + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.pytest.ini_options] +testpaths = ["tests"] diff --git a/packages/isaac_deploy_trt/scripts/generate_tensorrt_supported_layers.py b/packages/isaac_deploy_trt/scripts/generate_tensorrt_supported_layers.py new file mode 100755 index 00000000..7204c6db --- /dev/null +++ b/packages/isaac_deploy_trt/scripts/generate_tensorrt_supported_layers.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python3 +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Generate TensorRT supported-layer catalogs. Same as ``isaac_deploy_trt generate``.""" + +from __future__ import annotations + +import sys +from pathlib import Path + +_SRC = Path(__file__).resolve().parents[1] / "src" +if _SRC.is_dir() and str(_SRC) not in sys.path: + sys.path.insert(0, str(_SRC)) + +from isaac_deploy_trt.generate_cmd import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/packages/isaac_deploy_trt/scripts/merge_pipeline.py b/packages/isaac_deploy_trt/scripts/merge_pipeline.py new file mode 100755 index 00000000..e2edbe69 --- /dev/null +++ b/packages/isaac_deploy_trt/scripts/merge_pipeline.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Merge a LEAPP YAML pipeline into one ONNX graph for TensorRTNode (no Triton). + +Same as ``isaac_deploy_trt merge-pipeline``. +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +_SRC = Path(__file__).resolve().parents[1] / "src" +if _SRC.is_dir() and str(_SRC) not in sys.path: + sys.path.insert(0, str(_SRC)) + +from isaac_deploy_trt.cli import main + +if __name__ == "__main__": + raise SystemExit(main(["merge-pipeline", *sys.argv[1:]])) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/__init__.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/__init__.py new file mode 100644 index 00000000..ba8429b2 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/__init__.py @@ -0,0 +1,63 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Rewrite ONNX graphs so TensorRT can parse them, without LEAPP.""" + +from __future__ import annotations + +from typing import Any + +__version__ = "0.1.0" + +__all__ = [ + "apply_tensorrt_rewrites", + "check_onnx_ops_against_tensorrt", + "merge_leapp_onnx_pipeline", + "rewrite_directory", + "rewrite_onnx_file", + "rewrite_onnx_for_tensorrt", + "save_merged_pipeline", +] + + +def __getattr__(name: str) -> Any: + if name in {"rewrite_directory", "rewrite_onnx_file"}: + from isaac_deploy_trt.prepare import rewrite_directory, rewrite_onnx_file + + mapping = { + "rewrite_directory": rewrite_directory, + "rewrite_onnx_file": rewrite_onnx_file, + } + return mapping[name] + if name in { + "apply_tensorrt_rewrites", + "rewrite_onnx_for_tensorrt", + "surgery", + }: + import importlib + + surgery_mod = importlib.import_module("isaac_deploy_trt.surgery") + mapping = { + "apply_tensorrt_rewrites": surgery_mod.apply_tensorrt_rewrites, + "rewrite_onnx_for_tensorrt": surgery_mod.rewrite_onnx_for_tensorrt, + "surgery": surgery_mod, + } + return mapping[name] + if name == "check_onnx_ops_against_tensorrt": + from isaac_deploy_trt.validate import check_onnx_ops_against_tensorrt + + return check_onnx_ops_against_tensorrt + if name in {"merge_leapp_onnx_pipeline", "save_merged_pipeline"}: + from isaac_deploy_trt.pipeline_merge import ( + merge_leapp_onnx_pipeline, + save_merged_pipeline, + ) + + mapping = { + "merge_leapp_onnx_pipeline": merge_leapp_onnx_pipeline, + "save_merged_pipeline": save_merged_pipeline, + } + return mapping[name] + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/catalog.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/catalog.py new file mode 100644 index 00000000..440a661e --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/catalog.py @@ -0,0 +1,219 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Join onnx-tensorrt operators.md with TensorRT header enumerations.""" + +from __future__ import annotations + +import json +import re +from dataclasses import dataclass +from pathlib import Path +from typing import Dict, List, Optional + +from isaac_deploy_trt.headers import ( + TensorRTHeaderCatalog, + load_tensorrt_headers, + map_onnx_dtypes_to_nvinfer, + normalize_release_tag, +) + +DEFAULT_OPERATORS_MD_URL = ( + "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md" +) + +TYPE_ALIASES = { + "FLOAT32": "FP32", + "FLOAT": "FP32", + "FLOAT16": "FP16", + "BFLOAT16": "BF16", + "DOUBLE": "FP64", +} +KNOWN_DTYPES = { + "FP32", "FP16", "BF16", "FP8", "FP4", "FP64", + "INT8", "INT4", "INT32", "INT64", "UINT8", "BOOL", "TF32", +} + + +@dataclass +class OnnxOpRow: + name: str + supported: bool + types: List[str] + restrictions: str + + +def parse_operators_md(text: str, *, source: str = "operators.md") -> Dict[str, object]: + version = "unknown" + opset_min, opset_max = 9, 24 + header = re.search( + r"TensorRT\s+([0-9.]+)\s+supports operators in the inclusive range of opset\s+(\d+)\s+to opset\s+(\d+)", + text, + re.IGNORECASE, + ) + if header: + version = header.group(1) + opset_min = int(header.group(2)) + opset_max = int(header.group(3)) + + ops: List[OnnxOpRow] = [] + in_table = False + for raw_line in text.splitlines(): + line = raw_line.strip() + if line.startswith("## ") and "Operator Support Matrix" in line: + in_table = True + continue + if in_table and line.startswith("## "): + break + if not in_table or not line.startswith("|"): + continue + cells = [cell.strip() for cell in line.strip("|").split("|")] + if not cells or cells[0] in {"Operator", ""}: + continue + if set(cells[0]) <= {"-", ":"}: + continue + name = cells[0] + if not re.match(r"^[A-Za-z][A-Za-z0-9_]*$", name): + continue + supported_cell = cells[1] if len(cells) > 1 else "N" + supported = supported_cell.upper().startswith("Y") + types_cell = cells[2].strip() if len(cells) > 2 else "" + parts = [ + TYPE_ALIASES.get(part.strip().upper().replace(" ", ""), part.strip().upper().replace(" ", "")) + for part in types_cell.split(",") + if part.strip() + ] + types = [part for part in parts if part in KNOWN_DTYPES] + restrictions = cells[3] if len(cells) > 3 else "" + if not restrictions and types_cell and not types: + restrictions = types_cell + ops.append( + OnnxOpRow( + name=name, + supported=supported, + types=types, + restrictions=restrictions.strip(), + ) + ) + if not ops: + raise ValueError(f"No operator rows parsed from {source}") + return { + "tensorrt_version": version, + "opset_min": opset_min, + "opset_max": opset_max, + "source": source, + "ops": ops, + } + + +def catalog_fingerprint( + onnx_operators: Dict[str, object], + headers: Optional[TensorRTHeaderCatalog], +) -> tuple: + ops = tuple( + ( + name, + info.get("supported"), + tuple(info.get("types") or []), + info.get("restrictions"), + ) + for name, info in sorted(onnx_operators.items()) + ) + if headers is None: + header_key = None + else: + header_key = ( + tuple(headers.data_types), + tuple(headers.layer_types), + tuple(headers.builder_flags), + tuple(headers.network_definition_creation_flags), + ) + return (ops, header_key) + + +def build_catalog( + *, + operators_md: Optional[str] = None, + include_dir: Optional[str] = None, + fetch_headers: bool = False, + headers: Optional[TensorRTHeaderCatalog] = None, + releases: Optional[List[str]] = None, + headers_by_release: Optional[Dict[str, TensorRTHeaderCatalog]] = None, +) -> Dict[str, object]: + tags = [normalize_release_tag(tag) for tag in (releases or [])] or [None] + groups: Dict[tuple, Dict[str, object]] = {} + order: List[tuple] = [] + for tag in tags: + if headers_by_release is not None and tag is not None: + header_catalog = headers_by_release.get(tag) + elif headers is not None: + header_catalog = headers + elif include_dir: + header_catalog = load_tensorrt_headers(include_dir=include_dir, fetch=False) + elif tag is not None: + header_catalog = load_tensorrt_headers(ref=tag, fetch=True) + elif fetch_headers: + header_catalog = load_tensorrt_headers(fetch=True) + else: + header_catalog = None + + available = header_catalog.data_types if header_catalog is not None else None + onnx_operators: Dict[str, object] = {} + doc: Dict[str, object] = {} + if operators_md: + text = Path(operators_md).read_text(encoding="utf-8") + parsed = parse_operators_md(text, source=operators_md) + doc = { + "tensorrt_version": parsed["tensorrt_version"], + "opset_min": parsed["opset_min"], + "opset_max": parsed["opset_max"], + "source": parsed["source"], + } + for op in parsed["ops"]: + onnx_operators[op.name] = { + "supported": op.supported, + "types": list(op.types), + "nvinfer_datatypes": map_onnx_dtypes_to_nvinfer( + op.types, available=available + ), + "restrictions": op.restrictions, + } + fingerprint = catalog_fingerprint(onnx_operators, header_catalog) + if fingerprint not in groups: + groups[fingerprint] = { + "operators_md": doc, + "nvinfer": None if header_catalog is None else header_catalog.as_dict(), + "onnx_operators": onnx_operators, + "releases": [], + } + order.append(fingerprint) + if tag is not None: + groups[fingerprint]["releases"].append(tag) + + databases = [] + for fingerprint in order: + group = groups[fingerprint] + supported = sorted(set(group["releases"])) + if not supported and group["operators_md"].get("tensorrt_version"): + version = group["operators_md"]["tensorrt_version"] + if version and version != "unknown": + supported = [normalize_release_tag(version)] + payload = { + "supported_releases": supported, + "operators_md": group["operators_md"], + "nvinfer": group["nvinfer"], + "onnx_operators": group["onnx_operators"], + } + databases.append(payload) + + if len(databases) == 1: + return databases[0] + return {"databases": databases} + + +def write_catalog(catalog: Dict[str, object], output: Path) -> Path: + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(json.dumps(catalog, indent=2) + "\n", encoding="utf-8") + return output diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py new file mode 100644 index 00000000..fdeec356 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py @@ -0,0 +1,253 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""CLI: rewrite / check ONNX models for TensorRT.""" + +from __future__ import annotations + +import argparse +import logging +import os +import sys + +from isaac_deploy_trt.catalog import build_catalog, write_catalog +from isaac_deploy_trt.generate_cmd import add_generate_arguments, run_generate +from isaac_deploy_trt.headers import default_include_dir +from isaac_deploy_trt.pipeline_merge import ( + merge_leapp_onnx_pipeline, + save_merged_pipeline, +) +from isaac_deploy_trt.prepare import rewrite_directory, rewrite_onnx_file +from isaac_deploy_trt.validate import validate_onnx_for_tensorrt + + +def _add_logging() -> None: + logging.basicConfig(level=logging.INFO, format="[%(levelname)s]: %(message)s") + + +def _cmd_rewrite(args: argparse.Namespace) -> int: + result = rewrite_onnx_file(args.onnx, args.output) + action = "rewrote" if result.rewritten else "copied" + extra = f" ({len(result.rewritten_nodes)} nodes)" if result.rewritten else "" + print(f"{action} {result.filename}{extra} -> {result.output_path}") + return 0 + + +def _cmd_rewrite_dir(args: argparse.Namespace) -> int: + results = rewrite_directory(args.input_dir, args.output) + print(f"Wrote {len(results)} ONNX file(s) to {os.path.abspath(args.output)}") + for item in results: + action = "rewrote" if item.rewritten else "copied" + extra = f" ({len(item.rewritten_nodes)} nodes)" if item.rewritten else "" + print(f" {action} {item.filename}{extra}") + return 0 + + +def _cmd_merge_pipeline(args: argparse.Namespace) -> int: + yaml_path = os.path.abspath(os.path.expanduser(args.yaml_path)) + if not os.path.isfile(yaml_path): + print(f"error: YAML not found: {yaml_path}", file=sys.stderr) + return 2 + try: + result = merge_leapp_onnx_pipeline( + yaml_path, + model_dir=args.model_dir, + rewrite=args.rewrite, + ) + out_yaml = save_merged_pipeline( + result, + os.path.expanduser(args.output), + yaml_path=args.yaml_out, + ) + except Exception as exc: + logging.getLogger(__name__).error("Failed to merge LEAPP pipeline: %s", exc) + return 1 + if result.rewritten_models: + print(f"rewrote before merge: {', '.join(result.rewritten_models)}") + print(f"wrote {os.path.abspath(os.path.expanduser(args.output))}") + print(f"wrote {out_yaml}") + print(f"TensorRTNode inputs: {result.input_tensor_names}") + print(f"TensorRTNode outputs: {result.output_tensor_names}") + return 0 + + +def _cmd_check(args: argparse.Namespace) -> int: + paths = [args.onnx] if args.onnx else [] + if args.onnx_dir: + for name in sorted(os.listdir(args.onnx_dir)): + if name.endswith(".onnx"): + paths.append(os.path.join(args.onnx_dir, name)) + failed = 0 + for path in paths: + result = validate_onnx_for_tensorrt( + path, + build=args.build, + strict=False, + ) + status = "ok" if result.ok else "FAIL" + print(f"{status} {path}") + if not result.ok: + failed += 1 + for err in result.errors: + print(f" {err}") + if args.strict and failed: + return 1 + return 0 + + +def _cmd_catalog(args: argparse.Namespace) -> int: + releases = [] + if args.releases: + releases = [name.strip() for name in args.releases.split(",") if name.strip()] + include_dir = args.include_dir + if include_dir is None and not releases: + include_dir = default_include_dir() + if not include_dir and not args.fetch_headers and not args.operators_md and not releases: + print( + "error: pass --operators-md and/or --include-dir / --fetch-headers / --releases", + file=sys.stderr, + ) + return 1 + catalog = build_catalog( + operators_md=args.operators_md, + include_dir=include_dir, + fetch_headers=args.fetch_headers or bool(releases), + releases=releases or None, + ) + path = write_catalog(catalog, os.path.abspath(args.output)) + nvinfer = catalog.get("nvinfer") or {} + ops = catalog.get("onnx_operators") or {} + print(f"wrote {path}") + if catalog.get("supported_releases"): + print(f" supported_releases: {catalog['supported_releases']}") + if catalog.get("databases"): + for database in catalog["databases"]: + print( + f" database supported_releases={database.get('supported_releases')}" + ) + if nvinfer: + print( + f" headers: {len(nvinfer.get('data_types') or [])} DataType, " + f"{len(nvinfer.get('layer_type_names') or [])} LayerType, " + f"strongly_typed={nvinfer.get('strongly_typed')}" + ) + if ops: + print(f" onnx ops: {len(ops)}") + return 0 + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser( + prog="isaac_deploy_trt", + description=( + "GraphSurgeon ONNX rewrites for TensorRT: UINT8 intermediate Casts, " + "Resize antialias, Reshape rank > 8. Graph I/O names are preserved. " + "Merge a LEAPP YAML DAG into one ONNX graph for TensorRTNode. " + "Also join operators.md with NvInfer.h DataType/LayerType catalogs." + ), + ) + sub = parser.add_subparsers(dest="command", required=True) + + rewrite = sub.add_parser("rewrite", help="Rewrite one ONNX file") + rewrite.add_argument("onnx", help="Input .onnx path") + rewrite.add_argument("-o", "--output", required=True, help="Output .onnx path") + rewrite.set_defaults(handler=_cmd_rewrite) + + rewrite_dir = sub.add_parser( + "rewrite-dir", help="Rewrite every .onnx in a directory" + ) + rewrite_dir.add_argument("input_dir", help="Directory of .onnx files") + rewrite_dir.add_argument("-o", "--output", required=True, help="Output directory") + rewrite_dir.set_defaults(handler=_cmd_rewrite_dir) + + merge = sub.add_parser( + "merge-pipeline", + help="Merge a LEAPP YAML pipeline into one ONNX graph for TensorRTNode", + ) + merge.add_argument( + "yaml_path", + help="LEAPP export YAML (models + pipeline.data_flow)", + ) + merge.add_argument( + "-o", + "--output", + required=True, + help="Destination .onnx path (writes sibling .yaml unless --yaml-out)", + ) + merge.add_argument( + "--model-dir", + default=None, + help="Directory containing per-node ONNX files (default: YAML directory)", + ) + merge.add_argument( + "--yaml-out", + default=None, + help="Optional path for the single-model YAML / TensorRTNode name lists", + ) + merge.add_argument( + "--rewrite", + action="store_true", + help=( + "Apply TensorRT GraphSurgeon rewrites to each subgraph before merge" + ), + ) + merge.set_defaults(handler=_cmd_merge_pipeline) + + check = sub.add_parser("check", help="Catalog-check ONNX vs TensorRT ops.md") + src = check.add_mutually_exclusive_group(required=True) + src.add_argument("--onnx", help="Single .onnx file") + src.add_argument("--onnx-dir", help="Directory of .onnx files") + check.add_argument("--build", action="store_true", help="Also TensorRT parse/build") + check.add_argument("--strict", action="store_true", help="Exit 1 if any check fails") + check.set_defaults(handler=_cmd_check) + + catalog = sub.add_parser( + "catalog", + help="Join operators.md with TensorRT header enumerations", + ) + catalog.add_argument( + "--operators-md", + help="Local onnx-tensorrt docs/operators.md", + ) + catalog.add_argument( + "--include-dir", + default=None, + help="TensorRT include dir (NvInfer.h); or set TENSORRT_INCLUDE_DIR when --releases is omitted", + ) + catalog.add_argument( + "--fetch-headers", + action="store_true", + help="Download NvInfer*.h from NVIDIA/TensorRT GitHub", + ) + catalog.add_argument( + "--releases", + default=None, + help=( + "Comma-separated NVIDIA/TensorRT tags (v11.2,v11.1). " + "Identical header+ops tables share one database." + ), + ) + catalog.add_argument( + "-o", + "--output", + required=True, + help="Output JSON path", + ) + catalog.set_defaults(handler=_cmd_catalog) + + generate = sub.add_parser( + "generate", + help="Build per-release TensorRT JSON/Markdown catalogs (noble/noble-fastos/noble-jetpack)", + ) + add_generate_arguments(generate) + generate.set_defaults(handler=run_generate) + + args = parser.parse_args(argv) + _add_logging() + return args.handler(args) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/generate_cmd.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/generate_cmd.py new file mode 100644 index 00000000..a03912fe --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/generate_cmd.py @@ -0,0 +1,149 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""CLI helpers for generating TensorRT platform catalogs.""" + +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path + +from isaac_deploy_trt.headers import default_include_dir +from isaac_deploy_trt.platform_catalog import ( + DEFAULT_OPERATORS_MD_URL, + DEFAULT_PLATFORMS, + TARGET_CUDA, + generate, + resolve_platform_name, +) + + +def add_generate_arguments(parser: argparse.ArgumentParser) -> None: + parser.add_argument( + "-o", + "--output", + default="tensorrt_catalogs", + help="Directory for per-platform JSON/Markdown catalogs", + ) + parser.add_argument( + "--platforms", + default=",".join(DEFAULT_PLATFORMS), + help="Comma-separated subset: noble,noble-fastos,noble-jetpack " + "(SKU aliases: x86,orin,thor,dgx)", + ) + parser.add_argument( + "--operators-md", + default=None, + help="Local onnx-tensorrt docs/operators.md (skip network fetch)", + ) + parser.add_argument( + "--operators-url", + default=DEFAULT_OPERATORS_MD_URL, + help="operators.md URL used when --operators-md is omitted", + ) + parser.add_argument( + "--format", + dest="formats", + default="json,md", + help="Output formats: json,md", + ) + parser.add_argument( + "--write-python", + default=None, + help="Also write an unfiltered tensorrt_onnx_ops.py catalog", + ) + parser.add_argument( + "--include-dir", + default=None, + help=( + "TensorRT include directory with NvInfer.h / NvInferRuntimeBase.h " + "(or set TENSORRT_INCLUDE_DIR when --releases is omitted)" + ), + ) + parser.add_argument( + "--fetch-headers", + action="store_true", + help="Download NvInfer*.h from NVIDIA/TensorRT GitHub when --include-dir is omitted", + ) + parser.add_argument( + "--releases", + default=None, + help=( + "Comma-separated NVIDIA/TensorRT GitHub tags (v11.2,v10.16). " + "Identical parsed tables share one database." + ), + ) + parser.add_argument( + "--print-summary", + action="store_true", + help="Print supported/unsupported counts to stdout", + ) + + +def run_generate(args: argparse.Namespace) -> int: + platforms = [ + resolve_platform_name(name) + for name in args.platforms.split(",") + if name.strip() + ] + formats = [name.strip().lower() for name in args.formats.split(",") if name.strip()] + releases = [] + if args.releases: + releases = [name.strip() for name in args.releases.split(",") if name.strip()] + include_dir = args.include_dir + if include_dir is None and not releases: + include_dir = default_include_dir() + try: + result = generate( + platforms=platforms, + operators_md=args.operators_md, + operators_url=args.operators_url, + output_dir=Path(args.output), + formats=formats, + write_python=Path(args.write_python) if args.write_python else None, + include_dir=include_dir, + fetch_headers=args.fetch_headers or bool(releases), + releases=releases, + ) + except Exception as exc: + print(f"error: {exc}", file=sys.stderr) + return 1 + + if args.print_summary: + print(json.dumps(result["doc"], indent=2)) + for database in result.get("databases") or []: + print( + f"database {database['id']}: " + f"supported_releases={database['supported_releases']}" + ) + for catalog in result["catalogs"]: + print( + f"{catalog['platform']}: " + f"{len(catalog['onnx_supported'])} supported, " + f"{len(catalog['onnx_unsupported'])} unsupported ONNX ops, " + f"DLA={catalog['dla']}" + ) + for path in result["written"]: + print(path) + if result["python"]: + print(result["python"]) + return 0 + + +def parse_args(argv: list[str] | None = None) -> argparse.Namespace: + parser = argparse.ArgumentParser( + description=( + f"Generate TensorRT supported-layer catalogs for CUDA {TARGET_CUDA} " + f"({', '.join(DEFAULT_PLATFORMS)})" + ), + ) + add_generate_arguments(parser) + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> int: + return run_generate(parse_args(argv)) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/headers.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/headers.py new file mode 100644 index 00000000..0b62ae0c --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/headers.py @@ -0,0 +1,269 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Parse TensorRT public headers for DataType, LayerType, and strongly-typed flags. + +ONNX operator Y/N coverage still comes from onnx-tensorrt ``operators.md``. +Headers add nvinfer1 enumerations so catalogs can annotate ONNX dtypes with +``kFLOAT`` / ``kHALF`` / … and record ``NetworkDefinitionCreationFlag::kSTRONGLY_TYPED``. + +Default sources (override with a local TensorRT ``include/``):: + + https://github.com/NVIDIA/TensorRT/tree/main/include +""" + +from __future__ import annotations + +import os +import re +import urllib.error +import urllib.request +from dataclasses import dataclass, field +from pathlib import Path +from typing import Dict, Iterable, List, Optional, Sequence + +DEFAULT_TENSORRT_REPO = "NVIDIA/TensorRT" +DEFAULT_HEADER_REF = "main" +DEFAULT_HEADER_BASE = ( + f"https://raw.githubusercontent.com/{DEFAULT_TENSORRT_REPO}/{DEFAULT_HEADER_REF}/include" +) +DEFAULT_HEADER_FILES = ( + "NvInferRuntimeBase.h", + "NvInfer.h", + "NvInferRuntime.h", +) + +# operators.md tokens → nvinfer1::DataType enumerators in the headers. +ONNX_TYPE_TO_NVINFER: Dict[str, str] = { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT", # TF32 is a compute mode on kFLOAT, not a DataType +} + +STRONGLY_TYPED_FLAG = "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED" +STRONGLY_TYPED_NOTE = ( + "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; " + "the flag is retained for API compatibility). Tensor DataType is " + "authoritative; TensorRT will not implicitly cast. Listed " + "nvinfer_datatypes must match the ONNX/TRT tensor types." +) + +_ENUM_NAMES = ( + "DataType", + "LayerType", + "BuilderFlag", + "NetworkDefinitionCreationFlag", +) +_ENUM_BODY = re.compile( + r"enum\s+class\s+(" + + "|".join(_ENUM_NAMES) + + r")\b[^{]*\{(.*?)\};", + re.DOTALL, +) +_ENUM_MEMBER = re.compile(r"(?:^|[,{])\s*k([A-Z][A-Z0-9_]*)\b") +_COMMENT_BLOCK = re.compile(r"/\*.*?\*/", re.DOTALL) +_LINE_COMMENT = re.compile(r"//.*?$", re.MULTILINE) +_SKIP_MEMBERS = {"kMAX", "kVALUE"} + + +@dataclass +class TensorRTHeaderCatalog: + """Enumerations extracted from TensorRT headers.""" + + source: List[str] = field(default_factory=list) + data_types: List[str] = field(default_factory=list) + layer_types: List[str] = field(default_factory=list) + builder_flags: List[str] = field(default_factory=list) + network_definition_creation_flags: List[str] = field(default_factory=list) + + @property + def strongly_typed(self) -> bool: + return "kSTRONGLY_TYPED" in self.network_definition_creation_flags or ( + "kSTRONGLY_TYPED" in self.builder_flags + ) + + @property + def layer_type_names(self) -> List[str]: + """LayerType enumerators without the ``k`` prefix (CONVOLUTION, …).""" + names: List[str] = [] + for member in self.layer_types: + if member in _SKIP_MEMBERS: + continue + names.append(member[1:] if member.startswith("k") else member) + return names + + def map_onnx_dtypes(self, onnx_types: Sequence[str]) -> List[str]: + available = self.data_types or None + return map_onnx_dtypes_to_nvinfer(onnx_types, available=available) + + def as_dict(self) -> Dict[str, object]: + return { + "source": list(self.source), + "data_types": list(self.data_types), + "layer_types": list(self.layer_types), + "layer_type_names": self.layer_type_names, + "builder_flags": list(self.builder_flags), + "network_definition_creation_flags": list( + self.network_definition_creation_flags + ), + "strongly_typed": self.strongly_typed, + "strongly_typed_flag": STRONGLY_TYPED_FLAG if self.strongly_typed else None, + "strongly_typed_note": STRONGLY_TYPED_NOTE if self.strongly_typed else None, + "onnx_type_to_nvinfer": dict(ONNX_TYPE_TO_NVINFER), + } + + +def map_onnx_dtypes_to_nvinfer( + onnx_types: Sequence[str], + *, + available: Optional[Sequence[str]] = None, +) -> List[str]: + """Map operators.md type tokens to nvinfer1::DataType enumerators.""" + allowed = set(available) if available else None + mapped: List[str] = [] + seen = set() + for token in onnx_types: + enumerator = ONNX_TYPE_TO_NVINFER.get(token.upper().replace(" ", "")) + if enumerator is None: + continue + if allowed is not None and enumerator not in allowed: + continue + if enumerator not in seen: + seen.add(enumerator) + mapped.append(enumerator) + return mapped + + +def _strip_comments(text: str) -> str: + text = _COMMENT_BLOCK.sub("", text) + return _LINE_COMMENT.sub("", text) + + +def _unique_members(body: str) -> List[str]: + members = [f"k{name}" for name in _ENUM_MEMBER.findall(body)] + unique: List[str] = [] + seen = set() + for member in members: + if member in _SKIP_MEMBERS or member in seen: + continue + seen.add(member) + unique.append(member) + return unique + + +def parse_tensorrt_headers( + texts: Iterable[str], + *, + sources: Optional[Sequence[str]] = None, +) -> TensorRTHeaderCatalog: + """Parse concatenated or multiple NvInfer*.h texts.""" + catalog = TensorRTHeaderCatalog(source=list(sources or [])) + cleaned = _strip_comments("\n".join(texts)) + found = {name: [] for name in _ENUM_NAMES} + for match in _ENUM_BODY.finditer(cleaned): + found[match.group(1)] = _unique_members(match.group(2)) + catalog.data_types = found["DataType"] + catalog.layer_types = found["LayerType"] + catalog.builder_flags = found["BuilderFlag"] + catalog.network_definition_creation_flags = found["NetworkDefinitionCreationFlag"] + return catalog + + +def _read_url(url: str, timeout: int = 60) -> str: + with urllib.request.urlopen(url, timeout=timeout) as response: + return response.read().decode("utf-8") + + +def default_include_dir() -> Optional[str]: + env = os.environ.get("TENSORRT_INCLUDE_DIR") or os.environ.get("TRT_INCLUDE_DIR") + if env and Path(env).is_dir(): + return env + return None + + +def normalize_release_tag(tag: str) -> str: + """Normalize a TensorRT GitHub release ref (``11.2`` → ``v11.2``).""" + cleaned = str(tag).strip() + if not cleaned: + raise ValueError("Empty TensorRT release tag") + if cleaned in {"main", "master", "HEAD"} or re.fullmatch(r"[0-9a-fA-F]{7,40}", cleaned): + return cleaned + if cleaned[0] in "vV" and len(cleaned) > 1 and cleaned[1].isdigit(): + return "v" + cleaned[1:] + if cleaned[0].isdigit(): + return "v" + cleaned + return cleaned + + +def header_base_url_for_ref( + ref: str = DEFAULT_HEADER_REF, + *, + repo: str = DEFAULT_TENSORRT_REPO, +) -> str: + """Raw GitHub include/ URL for a TensorRT tag, branch, or commit.""" + return f"https://raw.githubusercontent.com/{repo}/{normalize_release_tag(ref)}/include" + + +def load_tensorrt_headers( + *, + include_dir: Optional[str] = None, + header_files: Sequence[str] = DEFAULT_HEADER_FILES, + header_base_url: Optional[str] = None, + ref: str = DEFAULT_HEADER_REF, + fetch: bool = True, +) -> TensorRTHeaderCatalog: + """Load headers from a local TensorRT include dir or a GitHub ref.""" + texts: List[str] = [] + sources: List[str] = [] + include_dir = include_dir or (None if fetch else default_include_dir()) + base = header_base_url or header_base_url_for_ref(ref) + if include_dir: + root = Path(include_dir) + for name in header_files: + path = root / name + if not path.is_file(): + nested = root / "NvInfer" / name + path = nested if nested.is_file() else path + if path.is_file(): + texts.append(path.read_text(encoding="utf-8", errors="replace")) + sources.append(str(path)) + if not texts: + raise FileNotFoundError( + f"No TensorRT headers {list(header_files)} under {include_dir}" + ) + elif fetch: + for name in header_files: + url = f"{base.rstrip('/')}/{name}" + try: + texts.append(_read_url(url)) + except urllib.error.HTTPError as exc: + if exc.code == 404: + continue + raise + sources.append(url) + if not texts: + raise FileNotFoundError( + f"No TensorRT headers {list(header_files)} at {base}" + ) + else: + raise ValueError("Pass include_dir or fetch=True") + catalog = parse_tensorrt_headers(texts, sources=sources) + catalog.source = list(catalog.source) + return catalog diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py new file mode 100644 index 00000000..33ac4d2a --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py @@ -0,0 +1,458 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Merge a LEAPP ONNX pipeline into one graph for TensorRTNode (no Triton). + +LEAPP export is one ONNX file per node plus YAML ``pipeline.data_flow``. +Isaac ROS ``TensorRTNode`` loads a single ``.plan`` with one TensorList in and +out, so the DAG has to be inlined first. This module prefixes each subgraph, +concatenates them, then rewires ``data_flow`` edges (including fan-out). + +``feedback_flow`` is not inlined: those tensors stay as extra graph inputs +(the previous tick's values), matching how Triton exposes them on the ensemble +boundary. + +Name collisions between pipeline inputs and outputs use the same convention as +Triton model repos: the input binding is renamed ``_in_``. +""" + +from __future__ import annotations + +import logging +import os +from dataclasses import dataclass, field +from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple + +import onnx +import yaml +from onnx import compose, helper + +from isaac_deploy_trt.prepare import needs_tensorrt_rewrite +from isaac_deploy_trt.surgery import rewrite_onnx_for_tensorrt + +logger = logging.getLogger(__name__) + + +def _split_ref(ref: str) -> Tuple[str, str]: + model, sep, tensor = ref.partition("/") + if not sep or not model or not tensor: + raise ValueError(f"Expected 'model/tensor' reference, got {ref!r}") + return model, tensor + + +def _prefixed(model: str, tensor: str) -> str: + return f"{model}__{tensor}" + + +def _topo_models(model_names: Sequence[str], data_flow: Mapping[str, Any]) -> List[str]: + """Stable topological order of LEAPP model names.""" + incoming: Dict[str, set[str]] = {name: set() for name in model_names} + for source, targets in (data_flow or {}).items(): + src_model, _ = _split_ref(source) + for target in targets or []: + dst_model, _ = _split_ref(target) + if src_model == dst_model: + continue + if dst_model in incoming: + incoming[dst_model].add(src_model) + ordered: List[str] = [] + remaining = list(model_names) + while remaining: + ready = [name for name in remaining if not incoming[name] - set(ordered)] + if not ready: + raise ValueError( + "Pipeline data_flow has a cycle; cannot merge into one ONNX graph" + ) + name = ready[0] + remaining.remove(name) + ordered.append(name) + for other in remaining: + incoming[other].discard(name) + return ordered + + +def _load_model(path: str) -> onnx.ModelProto: + """Load only the ONNX protobuf; keep large initializers external.""" + return onnx.load(path, load_external_data=False) + + +def _iter_graphs(graph: onnx.GraphProto): + yield graph + for node in graph.node: + for attr in node.attribute: + if attr.HasField("g"): + yield from _iter_graphs(attr.g) + for subgraph in attr.graphs: + yield from _iter_graphs(subgraph) + + +def _iter_tensors(model: onnx.ModelProto): + for graph in _iter_graphs(model.graph): + yield from graph.initializer + for node in graph.node: + for attr in node.attribute: + if attr.HasField("t"): + yield attr.t + yield from attr.tensors + + +def _external_locations(model: onnx.ModelProto) -> set[str]: + locations = set() + for tensor in _iter_tensors(model): + for entry in tensor.external_data: + if entry.key == "location": + locations.add(entry.value) + return locations + + +def _copy_graph_fields(dst: onnx.GraphProto, src: onnx.GraphProto) -> None: + dst.node.extend(src.node) + dst.initializer.extend(src.initializer) + dst.sparse_initializer.extend(src.sparse_initializer) + dst.input.extend(src.input) + dst.output.extend(src.output) + dst.value_info.extend(src.value_info) + + +def _replace_tensor_name(graph: onnx.GraphProto, old: str, new: str) -> None: + if old == new: + return + for node in graph.node: + for i, name in enumerate(node.input): + if name == old: + node.input[i] = new + for i, name in enumerate(node.output): + if name == old: + node.output[i] = new + for collection in ( + graph.input, + graph.output, + graph.value_info, + graph.initializer, + graph.sparse_initializer, + ): + for item in collection: + if item.name == old: + item.name = new + + +def _remove_graph_input(graph: onnx.GraphProto, name: str) -> None: + keep = [item for item in graph.input if item.name != name] + del graph.input[:] + graph.input.extend(keep) + + +def _remove_graph_output(graph: onnx.GraphProto, name: str) -> None: + keep = [item for item in graph.output if item.name != name] + del graph.output[:] + graph.output.extend(keep) + + +def _value_info_by_name(graph: onnx.GraphProto, name: str): + for item in list(graph.input) + list(graph.output) + list(graph.value_info): + if item.name == name: + return item + return None + + +@dataclass +class MergedPipelineResult: + """Result of ``merge_leapp_onnx_pipeline``.""" + + model: onnx.ModelProto + input_tensor_names: List[str] = field(default_factory=list) + output_tensor_names: List[str] = field(default_factory=list) + input_rename: Dict[str, str] = field(default_factory=dict) + external_data_sources: Dict[str, str] = field(default_factory=dict) + yaml_spec: Dict[str, Any] = field(default_factory=dict) + rewritten_models: List[str] = field(default_factory=list) + + +def merge_leapp_onnx_pipeline( + yaml_path: str, + *, + model_dir: Optional[str] = None, + rewrite: bool = False, +) -> MergedPipelineResult: + """Build one ONNX graph from a LEAPP export YAML and sibling ``.onnx`` files. + + ``model_dir`` defaults to the YAML's directory. Relative ``parameters.model_path`` + values are resolved against that directory. + + If ``rewrite`` is true, apply TensorRT GraphSurgeon edits (UINT8 Cast, + Resize antialias, rank>8 Reshape) to each subgraph before inlining. + """ + yaml_path = os.path.abspath(yaml_path) + model_dir = os.path.abspath(model_dir or os.path.dirname(yaml_path)) + with open(yaml_path, encoding="utf-8") as handle: + spec = yaml.safe_load(handle) or {} + models_cfg = spec.get("models") + pipeline = spec.get("pipeline") or {} + if not isinstance(models_cfg, dict) or not models_cfg: + raise ValueError(f"{yaml_path} has no models section") + + data_flow = pipeline.get("data_flow") or {} + feedback_flow = pipeline.get("feedback_flow") or {} + graph_inputs = pipeline.get("inputs") or {} + graph_outputs = pipeline.get("outputs") or {} + + model_names = list(models_cfg.keys()) + order = _topo_models(model_names, data_flow) + + prefixed: Dict[str, onnx.ModelProto] = {} + opsets: List[int] = [] + ir_version = 0 + external_data_sources: Dict[str, str] = {} + rewritten_models: List[str] = [] + for name, cfg in models_cfg.items(): + rel = ((cfg or {}).get("parameters") or {}).get("model_path", "") + if not rel: + raise ValueError(f"Model {name!r} has no parameters.model_path") + path = rel if os.path.isabs(rel) else os.path.join(model_dir, rel) + if not os.path.isfile(path): + raise FileNotFoundError(f"ONNX for model {name!r} not found: {path}") + logger.info("Loading %s from %s", name, path) + raw = _load_model(path) + if rewrite and needs_tensorrt_rewrite(raw): + logger.info("Rewriting %s for TensorRT before merge", name) + raw = rewrite_onnx_for_tensorrt(raw) + rewritten_models.append(name) + for location in _external_locations(raw): + source = os.path.abspath(os.path.join(os.path.dirname(path), location)) + previous = external_data_sources.get(location) + if previous is not None and previous != source: + raise ValueError( + f"External-data location {location!r} is ambiguous: " + f"{previous} vs {source}. Rename one source artifact first." + ) + if not os.path.isfile(source): + raise FileNotFoundError( + f"External data for model {name!r} not found: {source}" + ) + external_data_sources[location] = source + ir_version = max(ir_version, raw.ir_version) + for imp in raw.opset_import: + if imp.domain in ("", "ai.onnx"): + opsets.append(imp.version) + prefix = f"{name}__" + try: + prefixed[name] = compose.add_prefix(raw, prefix=prefix, inplace=False) + except TypeError: + prefixed[name] = compose.add_prefix(raw, prefix) + + combined = helper.make_graph( + nodes=[], + name="leapp_merged_pipeline", + inputs=[], + outputs=[], + ) + for name in order: + _copy_graph_fields(combined, prefixed[name].graph) + + for source, targets in data_flow.items(): + src_model, src_tensor = _split_ref(source) + producer = _prefixed(src_model, src_tensor) + if _value_info_by_name(combined, producer) is None: + raise ValueError(f"data_flow source {source} not in merged graph") + for target in targets or []: + dst_model, dst_tensor = _split_ref(target) + consumer = _prefixed(dst_model, dst_tensor) + _replace_tensor_name(combined, consumer, producer) + _remove_graph_input(combined, producer) + + for source, targets in feedback_flow.items(): + src_model, src_tensor = _split_ref(source) + producer = _prefixed(src_model, src_tensor) + for target in targets or []: + dst_model, dst_tensor = _split_ref(target) + consumer = _prefixed(dst_model, dst_tensor) + if _value_info_by_name(combined, consumer) is None: + raise ValueError(f"feedback_flow target {target} not in merged graph") + if _value_info_by_name(combined, producer) is None: + raise ValueError(f"feedback_flow source {source} not in merged graph") + + pipeline_input_names: List[str] = [] + for model_name, tensors in graph_inputs.items(): + for tensor in tensors: + pipeline_input_names.append(_prefixed(model_name, tensor)) + + for targets in feedback_flow.values(): + for target in targets or []: + dst_model, dst_tensor = _split_ref(target) + name = _prefixed(dst_model, dst_tensor) + if name not in pipeline_input_names: + pipeline_input_names.append(name) + + pipeline_output_names: List[str] = [] + for model_name, tensors in graph_outputs.items(): + for tensor in tensors: + pipeline_output_names.append(_prefixed(model_name, tensor)) + for source in feedback_flow: + src_model, src_tensor = _split_ref(source) + name = _prefixed(src_model, src_tensor) + if name not in pipeline_output_names: + pipeline_output_names.append(name) + + wanted_inputs = set(pipeline_input_names) + wanted_outputs = set(pipeline_output_names) + for item in list(combined.input): + if item.name not in wanted_inputs: + _remove_graph_input(combined, item.name) + for item in list(combined.output): + if item.name not in wanted_outputs: + _remove_graph_output(combined, item.name) + + input_rename: Dict[str, str] = {} + output_originals = {name.split("__", 1)[1] for name in pipeline_output_names} + final_inputs: List[str] = [] + for prefixed_name in pipeline_input_names: + original = prefixed_name.split("__", 1)[1] + if original in output_originals: + public = f"_in_{original}" + input_rename[original] = public + else: + public = original + _replace_tensor_name(combined, prefixed_name, public) + final_inputs.append(public) + + final_outputs: List[str] = [] + for prefixed_name in pipeline_output_names: + original = prefixed_name.split("__", 1)[1] + current = prefixed_name + if _value_info_by_name(combined, current) is None: + current = original if _value_info_by_name(combined, original) else current + if current != original and _value_info_by_name(combined, current) is not None: + _replace_tensor_name(combined, current, original) + final_outputs.append(original) + + info = { + item.name: item + for item in list(combined.input) + list(combined.output) + list(combined.value_info) + } + del combined.input[:] + del combined.output[:] + for name in final_inputs: + item = info.get(name) + if item is None: + raise ValueError(f"Merged graph missing pipeline input {name}") + combined.input.append(item) + for name in final_outputs: + item = info.get(name) + if item is None: + raise ValueError(f"Merged graph missing pipeline output {name}") + combined.output.append(item) + + opset = max(opsets) if opsets else 17 + model = helper.make_model( + combined, + opset_imports=[helper.make_opsetid("", opset)], + ir_version=ir_version or 10, + ) + model.producer_name = "isaac_deploy_trt.merge_leapp_onnx_pipeline" + + yaml_out = { + "models": { + "pipeline": { + "inputs": [ + {"name": name, "dtype": "float32", "shape": [], "type": "tensor"} + for name in final_inputs + ], + "outputs": [ + {"name": name, "dtype": "float32", "shape": [], "type": "tensor"} + for name in final_outputs + ], + "parameters": { + "model_path": "pipeline.onnx", + "backend": "onnx", + }, + } + }, + "pipeline": { + "data_flow": {}, + "feedback_flow": {}, + "inputs": {"pipeline": list(final_inputs)}, + "outputs": {"pipeline": list(final_outputs)}, + }, + "tensor_rt_node": { + "input_tensor_names": list(final_inputs), + "output_tensor_names": list(final_outputs), + "note": ( + "Single-engine graph for TensorRTNode. Colliding input names " + "are _in_. Compile pipeline.onnx with trtexec, then set " + "engine_file_path / input_tensor_names / output_tensor_names." + ), + }, + } + meta_in = {} + meta_out = {} + for model_name, cfg in models_cfg.items(): + for item in (cfg or {}).get("inputs") or []: + meta_in[(model_name, item.get("name"))] = item + for item in (cfg or {}).get("outputs") or []: + meta_out[(model_name, item.get("name"))] = item + + def _enrich(entries: List[dict], kind: str) -> None: + for entry in entries: + public = entry["name"] + original = public[4:] if public.startswith("_in_") else public + source = meta_in if kind == "inputs" else meta_out + for (_mn, tname), item in source.items(): + if tname == original: + entry["dtype"] = item.get("dtype", entry["dtype"]) + entry["shape"] = list(item.get("shape") or []) + if item.get("kind"): + entry["kind"] = item["kind"] + if item.get("element_names"): + entry["element_names"] = item["element_names"] + break + + _enrich(yaml_out["models"]["pipeline"]["inputs"], "inputs") + _enrich(yaml_out["models"]["pipeline"]["outputs"], "outputs") + + return MergedPipelineResult( + model=model, + input_tensor_names=final_inputs, + output_tensor_names=final_outputs, + input_rename=input_rename, + external_data_sources=external_data_sources, + yaml_spec=yaml_out, + rewritten_models=rewritten_models, + ) + + +def save_merged_pipeline( + result: MergedPipelineResult, + onnx_path: str, + *, + yaml_path: Optional[str] = None, +) -> str: + """Write ``pipeline.onnx`` and sibling YAML. Returns the YAML path.""" + onnx_path = os.path.abspath(onnx_path) + parent = os.path.dirname(onnx_path) + if parent: + os.makedirs(parent, exist_ok=True) + onnx.save(result.model, onnx_path) + for location, source in result.external_data_sources.items(): + destination = os.path.abspath(os.path.join(parent, location)) + os.makedirs(os.path.dirname(destination), exist_ok=True) + if os.path.lexists(destination): + if os.path.realpath(destination) == os.path.realpath(source): + continue + os.remove(destination) + os.symlink(source, destination) + result.yaml_spec["models"]["pipeline"]["parameters"]["model_path"] = os.path.basename( + onnx_path + ) + out_yaml = yaml_path or os.path.splitext(onnx_path)[0] + ".yaml" + with open(out_yaml, "w", encoding="utf-8") as handle: + yaml.safe_dump(result.yaml_spec, handle, sort_keys=False) + logger.info( + "Wrote merged ONNX %s and YAML %s; inputs=%s outputs=%s", + onnx_path, + out_yaml, + result.input_tensor_names, + result.output_tensor_names, + ) + return out_yaml diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/platform_catalog.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/platform_catalog.py new file mode 100644 index 00000000..8bea08eb --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/platform_catalog.py @@ -0,0 +1,1159 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Generate TensorRT supported-layer catalogs for CUDA 13.2 platforms. + +ONNX operator coverage comes from the public ONNX-TensorRT matrix (same parser +across platforms). Hardware overlays then drop dtypes and native layers that +NVIDIA's support matrix / DLA docs do not list for that SKU. + +Native ``DataType`` / ``LayerType`` / ``NetworkDefinitionCreationFlag`` values +are parsed from TensorRT headers (local ``include/`` or GitHub) and joined onto +each ONNX row as ``nvinfer_datatypes``. Headers do not replace operators.md. + +This is not a live engine-build guarantee. +""" + +from __future__ import annotations + +import json +import re +import urllib.request +from dataclasses import dataclass, field +from pathlib import Path +from typing import Dict, Iterable, List, Optional, Sequence + +from isaac_deploy_trt.headers import ( + ONNX_TYPE_TO_NVINFER, + STRONGLY_TYPED_FLAG, + STRONGLY_TYPED_NOTE, + TensorRTHeaderCatalog, + load_tensorrt_headers, + map_onnx_dtypes_to_nvinfer, + normalize_release_tag, +) + +DEFAULT_OPERATORS_MD_URL = ( + "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md" +) + +# CUDA 13.2 is the toolkit the user asked to target. TensorRT *packages* may +# still be labeled cuda-13.3 while remaining compatible with CUDA 13.x. +TARGET_CUDA = "13.2" + +TYPE_ALIASES = { + "FLOAT32": "FP32", + "FLOAT": "FP32", + "FLOAT16": "FP16", + "BFLOAT16": "BF16", + "DOUBLE": "FP64", +} + +# TensorRT ILayerType names that exist in TRT 10.13–11.2. Live installs can +# replace this via probe_installed_tensorrt(). +TENSORRT_LAYER_TYPES = [ + "ACTIVATION", + "ASSERTION", + "ATTENTION", + "CAST", + "CONCATENATION", + "CONDITION", + "CONSTANT", + "CONVOLUTION", + "CUMULATIVE", + "DECONVOLUTION", + "DEQUANTIZE", + "DYNAMIC_QUANTIZE", + "EINSUM", + "ELEMENTWISE", + "FILL", + "GATHER", + "GRID_SAMPLE", + "IDENTITY", + "LOOP", + "LOOP_OUTPUT", + "LRN", + "MATRIX_MULTIPLY", + "NMS", + "NON_ZERO", + "NORMALIZATION", + "ONE_HOT", + "PADDING", + "PARAMETRIC_RELU", + "PLUGIN", + "PLUGIN_V2", + "PLUGIN_V3", + "POOLING", + "QUANTIZE", + "RAGGED_SOFTMAX", + "RECURRENCE", + "REDUCE", + "RESIZE", + "REVERSE_SEQUENCE", + "SCALE", + "SCATTER", + "SELECT", + "SHAPE", + "SHUFFLE", + "SLICE", + "SOFTMAX", + "SQUEEZE", + "TOPK", + "TRIP_LIMIT", + "UNARY", + "UNSQUEEZE", +] + +# Orin DLA (TensorRT 10.x / JetPack). TensorRT 11.x does not support DLA. +# Source: https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html +ORIN_DLA_LAYERS = { + "ACTIVATION": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU", + "CONCATENATION": "FP16, INT8; channel axis only", + "CONVOLUTION": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]", + "DECONVOLUTION": "FP16, INT8; 2D; no grouped/dilated; padding 0", + "ELEMENTWISE": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow", + "LRN": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS", + "PARAMETRIC_RELU": "FP16, INT8; slope must be a build-time constant", + "POOLING": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]", + "REDUCE": "FP16, INT8; 4D; MAX; CHW axes", + "RESIZE": "FP16, INT8; nearest [1,32], bilinear [1,4]", + "SCALE": "FP16, INT8; Uniform, Per-Channel, ElementWise", + "SHUFFLE": "FP16, INT8; 4D; no batch transpose", + "SLICE": "FP16, INT8; 4D; static slicing", + "SOFTMAX": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode", + "UNARY": "INT8; ABS, SIN, COS, ATAN", +} + + +@dataclass +class PlatformSpec: + """CUDA 13.2 target overlay.""" + + name: str + display_name: str + cuda: str + tensorrt: str + arch: str + compute_capability: str + gpu_precisions: List[str] + dla: bool + tensorrt_11: bool + isaac_debian_dist: str = "" + notes: List[str] = field(default_factory=list) + sources: List[str] = field(default_factory=list) + + +# NVIDIA support-matrix facts for CUDA 13.2-class stacks (JetPack 7.x / TRT 10.13+ +# / TRT 11.x CUDA 13 compatibility). Precision lists are hardware capabilities, +# not a promise every ONNX op builds in that dtype. +PLATFORMS: Dict[str, PlatformSpec] = { + "x86": PlatformSpec( + name="x86", + display_name="Linux x86_64 (CUDA 13.2)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + arch="Ampere / Ada / Hopper / Blackwell dGPU", + compute_capability="8.0–12.x (SKU-dependent)", + gpu_precisions=[ + "FP32", "TF32", "FP16", "BF16", "FP8", "FP4", "INT8", "INT4", + "INT32", "INT64", "UINT8", "BOOL", "FP64", + ], + dla=False, + tensorrt_11=True, + isaac_debian_dist="noble", + notes=[ + "Isaac Debian dist: noble (Ubuntu 24.04 amd64).", + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA.", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + ], + ), + "orin": PlatformSpec( + name="orin", + display_name="Jetson Orin (CUDA 13.2 / JetPack 7.2)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + arch="Ampere GA10B iGPU", + compute_capability="8.7", + gpu_precisions=["FP32", "TF32", "FP16", "INT8", "INT32", "INT64", "UINT8", "BOOL"], + dla=True, + tensorrt_11=False, + isaac_debian_dist="noble-jetpack", + notes=[ + "Isaac Debian dist: noble-jetpack (JetPack 7.x / TensorRT 10.16).", + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier).", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + ], + ), + "thor": PlatformSpec( + name="thor", + display_name="Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1)", + arch="Blackwell (Thor GPU)", + compute_capability="11.0", + gpu_precisions=[ + "FP32", "TF32", "FP16", "BF16", "FP8", "FP4", "INT8", "INT4", + "INT32", "INT64", "UINT8", "BOOL", + ], + dla=False, + tensorrt_11=False, + isaac_debian_dist="noble-jetpack", + notes=[ + "Isaac Debian dist: noble-jetpack (same apt pocket as Orin).", + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM).", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + ], + ), + "dgx": PlatformSpec( + name="dgx", + display_name="DGX Spark / DGX Blackwell (CUDA 13.2)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + arch="Blackwell GB10 (Spark) or B200/GB200 (DGX)", + compute_capability="10.0–12.x (SKU-dependent)", + gpu_precisions=[ + "FP32", "TF32", "FP16", "BF16", "FP8", "FP4", "INT8", "INT4", + "INT32", "INT64", "UINT8", "BOOL", "FP64", + ], + dla=False, + tensorrt_11=True, + isaac_debian_dist="noble-fastos", + notes=[ + "Isaac Debian dist for Spark: noble-fastos. DGX B200/GB200 x86 uses noble, not FastOS.", + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.0–13.2.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'noble' / 'x86' for Hopper-only boxes.", + "No DLA.", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + ], + ), + "noble": PlatformSpec( + name="noble", + display_name="Ubuntu 24.04 noble (amd64 / CUDA 13.2)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + arch="Ampere / Ada / Hopper / Blackwell dGPU", + compute_capability="8.0–12.x (SKU-dependent)", + gpu_precisions=[ + "FP32", "TF32", "FP16", "BF16", "FP8", "FP4", "INT8", "INT4", + "INT32", "INT64", "UINT8", "BOOL", "FP64", + ], + dla=False, + tensorrt_11=True, + isaac_debian_dist="noble", + notes=[ + "Isaac Debian dist noble: Ubuntu 24.04 amd64 (x86_64 dGPU).", + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA. Same overlay as the 'x86' SKU catalog.", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + ], + ), + "noble-fastos": PlatformSpec( + name="noble-fastos", + display_name="Ubuntu 24.04 noble-fastos (DGX Spark / GB10)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.15.x from FastOS (not TensorRT 11.x)", + arch="Blackwell GB10 (Spark, ARM)", + compute_capability="10.0", + gpu_precisions=[ + "FP32", "TF32", "FP16", "BF16", "FP8", "FP4", "INT8", "INT4", + "INT32", "INT64", "UINT8", "BOOL", + ], + dla=False, + tensorrt_11=False, + isaac_debian_dist="noble-fastos", + notes=[ + "Isaac Debian dist noble-fastos: DGX Spark / FastOS arm64.", + "CUDA toolkit on this pocket is often 13.0.x; TensorRT is 10.15.x.", + "Not JetPack and not Ubuntu amd64 noble. Do not use this overlay for Orin/Thor.", + "No DLA. Engines are not portable to Jetson or x86 dGPU.", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + ], + ), + "noble-jetpack": PlatformSpec( + name="noble-jetpack", + display_name="Ubuntu 24.04 noble-jetpack (Jetson / JetPack 7)", + cuda=TARGET_CUDA, + tensorrt="TensorRT 10.16.x from JetPack 7.2 (not TensorRT 11.x)", + arch="Orin GA10B iGPU and Thor Blackwell", + compute_capability="8.7 (Orin) / 11.0 (Thor)", + gpu_precisions=[ + "FP32", "TF32", "FP16", "BF16", "FP8", "FP4", "INT8", "INT4", + "INT32", "INT64", "UINT8", "BOOL", + ], + dla=True, + tensorrt_11=False, + isaac_debian_dist="noble-jetpack", + notes=[ + "Isaac Debian dist noble-jetpack: JetPack 7.x arm64 (Orin and Thor).", + "Stay on JetPack TensorRT 10.16; TensorRT 11.x is not a JetPack path.", + "Orin: no BF16/FP8/FP4; DLA FP16/INT8 for the DLA layer subset.", + "Thor: Blackwell FP8/FP4; no DLA. Engines are not portable between Orin and Thor.", + "This overlay keeps the union of GPU dtypes; drop BF16/FP8/FP4 yourself on Orin.", + "DLA rows apply to Orin only.", + ], + sources=[ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + ], + ), +} + +# Isaac ROS / Isaac Debian pocket names are the default generate targets. +DEFAULT_PLATFORMS = ("noble", "noble-fastos", "noble-jetpack") +PLATFORM_ALIASES = { + "amd64": "noble", + "x86_64": "noble", + "linux-x86": "noble", + "spark": "noble-fastos", + "fastos": "noble-fastos", + "dgx-spark": "noble-fastos", + "jetpack": "noble-jetpack", + "jetson": "noble-jetpack", + "jp7": "noble-jetpack", +} + + +def resolve_platform_name(name: str) -> str: + """Map aliases (amd64, spark, jetson) onto catalog keys.""" + cleaned = name.strip().lower().replace("_", "-") + return PLATFORM_ALIASES.get(cleaned, cleaned) + + +@dataclass +class OnnxOpRow: + name: str + supported: bool + types: List[str] + restrictions: str + + def as_leapp_dict( + self, + headers: Optional[TensorRTHeaderCatalog] = None, + ) -> Dict[str, object]: + available = headers.data_types if headers is not None else None + return { + "supported": self.supported, + "types": list(self.types), + "nvinfer_datatypes": map_onnx_dtypes_to_nvinfer( + self.types, available=available + ), + "restrictions": self.restrictions, + } + + +@dataclass +class OperatorsDoc: + tensorrt_version: str + opset_min: int + opset_max: int + source: str + ops: List[OnnxOpRow] + + +def normalize_dtype(token: str) -> str: + cleaned = token.strip().upper().replace(" ", "") + return TYPE_ALIASES.get(cleaned, cleaned) + + +KNOWN_DTYPES = { + "FP32", "FP16", "BF16", "FP8", "FP4", "FP64", + "INT8", "INT4", "INT32", "INT64", "UINT8", "BOOL", "TF32", +} + + +def parse_types(cell: str) -> List[str]: + if not cell or not cell.strip(): + return [] + parts = [normalize_dtype(part) for part in cell.split(",")] + return [part for part in parts if part in KNOWN_DTYPES] + + +def parse_operators_md(text: str, *, source: str = "operators.md") -> OperatorsDoc: + """Parse the ONNX-TensorRT operators.md support table.""" + version = "unknown" + opset_min, opset_max = 9, 24 + header = re.search( + r"TensorRT\s+([0-9.]+)\s+supports operators in the inclusive range of opset\s+(\d+)\s+to opset\s+(\d+)", + text, + re.IGNORECASE, + ) + if header: + version = header.group(1) + opset_min = int(header.group(2)) + opset_max = int(header.group(3)) + + ops: List[OnnxOpRow] = [] + in_table = False + for raw_line in text.splitlines(): + line = raw_line.strip() + if line.startswith("## ") and "Operator Support Matrix" in line: + in_table = True + continue + if in_table and line.startswith("## "): + break + if not in_table or not line.startswith("|"): + continue + cells = [cell.strip() for cell in line.strip("|").split("|")] + if not cells or cells[0] in {"Operator", ""}: + continue + if set(cells[0]) <= {"-", ":"}: + continue + name = cells[0] + if not re.match(r"^[A-Za-z][A-Za-z0-9_]*$", name): + continue + supported_cell = cells[1] if len(cells) > 1 else "N" + supported = supported_cell.upper().startswith("Y") + types = parse_types(cells[2] if len(cells) > 2 else "") + restrictions = cells[3] if len(cells) > 3 else "" + types_cell = cells[2].strip() if len(cells) > 2 else "" + if not restrictions and types_cell and not types: + restrictions = types_cell + ops.append( + OnnxOpRow( + name=name, + supported=supported, + types=types, + restrictions=restrictions.strip(), + ) + ) + + if not ops: + raise ValueError(f"No operator rows parsed from {source}") + return OperatorsDoc( + tensorrt_version=version, + opset_min=opset_min, + opset_max=opset_max, + source=source, + ops=ops, + ) + + +def load_operators_md( + *, + path: Optional[str] = None, + url: str = DEFAULT_OPERATORS_MD_URL, +) -> OperatorsDoc: + if path: + text = Path(path).read_text(encoding="utf-8") + return parse_operators_md(text, source=path) + with urllib.request.urlopen(url, timeout=60) as response: + text = response.read().decode("utf-8") + return parse_operators_md(text, source=url) + + +def _filter_types(types: Sequence[str], allowed: Sequence[str]) -> List[str]: + allowed_set = set(allowed) + # Integer/bool network types stay if the parser listed them, even when the + # GPU precision table is focused on floating/quantized compute. + keep_always = {"INT32", "INT64", "UINT8", "BOOL"} + out: List[str] = [] + for dtype in types: + if dtype in allowed_set or dtype in keep_always: + out.append(dtype) + return out + + +def apply_platform(doc: OperatorsDoc, platform: PlatformSpec) -> List[OnnxOpRow]: + rows: List[OnnxOpRow] = [] + extra = [] + if not platform.tensorrt_11 and doc.tensorrt_version.startswith("11"): + extra.append( + "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. " + "Treat newly added 11.x-only ops as unverified." + ) + for op in doc.ops: + types = _filter_types(op.types, platform.gpu_precisions) + restrictions = op.restrictions + if extra: + note = extra[0] + restrictions = f"{restrictions}; {note}".strip("; ") if restrictions else note + supported = op.supported + if supported and op.types and not types: + supported = False + drop_note = ( + f"All listed dtypes ({', '.join(op.types)}) are unavailable on " + f"{platform.display_name}" + ) + restrictions = f"{restrictions}; {drop_note}".strip("; ") + rows.append( + OnnxOpRow( + name=op.name, + supported=supported, + types=types, + restrictions=restrictions, + ) + ) + return rows + + +# Native layers that NVIDIA documents as TensorRT 11.x (not JetPack 10.x). +TRT11_ONLY_LAYERS = { + "ATTENTION", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "DYNAMIC_QUANTIZE", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE", +} + + +def layer_names_for_catalog( + headers: Optional[TensorRTHeaderCatalog] = None, +) -> List[str]: + names = list(TENSORRT_LAYER_TYPES) + if headers is None: + return names + seen = set(names) + for name in headers.layer_type_names: + if name not in seen: + seen.add(name) + names.append(name) + return names + + +def native_layers_for_platform( + platform: PlatformSpec, + *, + headers: Optional[TensorRTHeaderCatalog] = None, +) -> Dict[str, Dict[str, object]]: + layers: Dict[str, Dict[str, object]] = {} + trt11_only = TRT11_ONLY_LAYERS + for name in layer_names_for_catalog(headers): + gpu = True + notes = [] + if name in trt11_only and not platform.tensorrt_11: + gpu = False + notes.append("Documented as TensorRT 11.x native layer; not in JetPack 10.x") + dla = platform.dla and name in ORIN_DLA_LAYERS + if dla: + notes.append(ORIN_DLA_LAYERS[name]) + layers[name] = { + "gpu": gpu, + "dla": dla, + "notes": " ".join(notes), + } + return layers + + +def probe_installed_tensorrt() -> Optional[Dict[str, object]]: + try: + import tensorrt as trt # type: ignore + except Exception: + return None + members = [] + layer_type = getattr(trt, "LayerType", None) + if layer_type is not None and hasattr(layer_type, "__members__"): + members = sorted(layer_type.__members__) + return { + "version": getattr(trt, "__version__", "unknown"), + "layer_types": members, + } + + +def build_platform_catalog( + doc: OperatorsDoc, + platform: PlatformSpec, + *, + headers: Optional[TensorRTHeaderCatalog] = None, + supported_releases: Optional[Sequence[str]] = None, +) -> Dict[str, object]: + ops = apply_platform(doc, platform) + supported = [op.name for op in ops if op.supported] + unsupported = [op.name for op in ops if not op.supported] + nvinfer = ( + headers.as_dict() + if headers is not None + else { + "source": [], + "data_types": [], + "layer_types": [], + "layer_type_names": list(TENSORRT_LAYER_TYPES), + "builder_flags": [], + "network_definition_creation_flags": [], + "strongly_typed": None, + "strongly_typed_flag": STRONGLY_TYPED_FLAG, + "strongly_typed_note": STRONGLY_TYPED_NOTE, + "onnx_type_to_nvinfer": dict(ONNX_TYPE_TO_NVINFER), + } + ) + sources = list(platform.sources) + if headers is not None: + sources.extend(headers.source) + return { + "cuda": platform.cuda, + "platform": platform.name, + "isaac_debian_dist": platform.isaac_debian_dist, + "display_name": platform.display_name, + "tensorrt": platform.tensorrt, + "arch": platform.arch, + "compute_capability": platform.compute_capability, + "parser_tensorrt_version": doc.tensorrt_version, + "opset": {"min": doc.opset_min, "max": doc.opset_max}, + "source": doc.source, + "gpu_precisions": platform.gpu_precisions, + "dla": platform.dla, + "tensorrt_11": platform.tensorrt_11, + "notes": platform.notes, + "sources": sources, + "supported_releases": list(supported_releases or []), + "nvinfer": nvinfer, + "onnx_supported": supported, + "onnx_unsupported": unsupported, + "onnx_operators": {op.name: op.as_leapp_dict(headers) for op in ops}, + "tensorrt_layers": native_layers_for_platform(platform, headers=headers), + "installed_tensorrt": probe_installed_tensorrt(), + } + + +PYTHON_CATALOG_LOOKUP = ''' +def _normalize_tensorrt_version(version: str) -> str: + parts = [part.lstrip("vV") for part in str(version).strip().split(".") if part] + if len(parts) >= 2: + return f"{parts[0]}.{parts[1]}" + if parts: + return parts[0] + raise ValueError(f"Invalid TensorRT version: {version!r}") + + +def _normalize_release_tag(tag: str) -> str: + cleaned = str(tag).strip() + if cleaned[0] in "vV" and len(cleaned) > 1 and cleaned[1].isdigit(): + return "v" + cleaned[1:] + if cleaned and cleaned[0].isdigit(): + return "v" + cleaned + return cleaned + + +def _cuda_matches(entry: str, requested: str) -> bool: + want = requested.strip().lower() + have = entry.strip().lower() + if have.endswith(".x"): + return want == have[:-2] or want.startswith(have[:-1]) + return want == have or want.startswith(have + ".") + + +def _release_matches(catalog: TensorRTOnnxCatalogInfo, tensorrt: str) -> bool: + key = _normalize_tensorrt_version(tensorrt) + tag = _normalize_release_tag(tensorrt) + if catalog.get("tensorrt") and _normalize_tensorrt_version(catalog["tensorrt"]) == key: + return True + for release in catalog.get("supported_releases") or []: + if release == tensorrt or release == tag: + return True + if _normalize_tensorrt_version(release) == key: + return True + return False + + +def list_onnx_ops_catalogs() -> List[str]: + return sorted(TENSORRT_ONNX_CATALOGS) + + +def onnx_ops_catalog( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> TensorRTOnnxCatalogInfo: + if tensorrt: + key = _normalize_tensorrt_version(tensorrt) + if key in TENSORRT_ONNX_CATALOGS: + catalog = TENSORRT_ONNX_CATALOGS[key] + else: + catalog = next( + ( + entry + for entry in TENSORRT_ONNX_CATALOGS.values() + if _release_matches(entry, tensorrt) + ), + None, + ) + if catalog is None: + raise KeyError( + f"No ONNX operator catalog for TensorRT {tensorrt!r} " + f"(have {list_onnx_ops_catalogs()})" + ) + if cuda and not any(_cuda_matches(tag, cuda) for tag in catalog["cuda"]): + raise KeyError( + f"TensorRT {key} catalog does not list CUDA {cuda!r} " + f"(have {catalog['cuda']})" + ) + return catalog + if cuda: + matches = [ + TENSORRT_ONNX_CATALOGS[key] + for key in sorted(TENSORRT_ONNX_CATALOGS, reverse=True) + if any(_cuda_matches(tag, cuda) for tag in TENSORRT_ONNX_CATALOGS[key]["cuda"]) + ] + if not matches: + raise KeyError( + f"No ONNX operator catalog lists CUDA {cuda!r} " + f"(have {list_onnx_ops_catalogs()})" + ) + return matches[0] + return TENSORRT_ONNX_CATALOGS[TENSORRT_ONNX_DEFAULT_VERSION] + + +def onnx_ops_for_version( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> Dict[str, TensorRTOnnxOpInfo]: + return onnx_ops_catalog(tensorrt, cuda=cuda)["ops"] + + +def supported_onnx_ops( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> set[str]: + ops = onnx_ops_for_version(tensorrt, cuda=cuda) + return {name for name, info in ops.items() if info["supported"]} + + +def unsupported_onnx_ops( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> set[str]: + ops = onnx_ops_for_version(tensorrt, cuda=cuda) + return {name for name, info in ops.items() if not info["supported"]} +'''.lstrip() + + +def render_python_catalog( + doc: OperatorsDoc, + *, + supported_releases: Optional[Sequence[str]] = None, +) -> str: + """Emit a tensorrt_onnx_ops.py-style dict from the unfiltered parser table.""" + releases = list(supported_releases or infer_supported_releases(doc, ())) + lines = [ + "#", + "# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.", + "# SPDX-License-Identifier: Apache-2.0", + "#", + "", + '"""TensorRT ONNX operator support catalog.', + "", + f"Generated from TensorRT {doc.tensorrt_version}, ONNX opset " + f"{doc.opset_min}-{doc.opset_max}:", + f"{doc.source}", + "", + "Regenerate with:", + " isaac_deploy_trt generate --write-python \\", + " path/to/tensorrt_onnx_ops.py", + '"""', + "", + "from __future__ import annotations", + "", + "from typing import Dict, List, Optional, TypedDict", + "", + "", + "class TensorRTOnnxOpInfo(TypedDict):", + " supported: bool", + " types: List[str]", + " nvinfer_datatypes: List[str]", + " restrictions: str", + "", + "", + "class TensorRTOnnxCatalogInfo(TypedDict):", + " tensorrt: str", + " cuda: List[str]", + " opset_min: int", + " opset_max: int", + " source: str", + " supported_releases: List[str]", + " ops: Dict[str, TensorRTOnnxOpInfo]", + "", + "", + f'TENSORRT_ONNX_DEFAULT_VERSION = "{doc.tensorrt_version}"', + f"TENSORRT_ONNX_OPSET_MIN = {doc.opset_min}", + f"TENSORRT_ONNX_OPSET_MAX = {doc.opset_max}", + "", + "TENSORRT_ONNX_OPS: Dict[str, TensorRTOnnxOpInfo] = {", + "", + ] + for op in doc.ops: + types = ", ".join(repr(dtype) for dtype in op.types) + restrictions = op.restrictions.replace("\\", "\\\\").replace("'", "\\'") + lines.append(f' "{op.name}": {{') + lines.append(f' "supported": {op.supported},') + lines.append(f" \"types\": [{types}],") + nvinfer_types = ", ".join( + repr(dtype) for dtype in map_onnx_dtypes_to_nvinfer(op.types) + ) + lines.append(f" \"nvinfer_datatypes\": [{nvinfer_types}],") + lines.append(f" \"restrictions\": '{restrictions}',") + lines.append(" },") + lines.extend( + [ + "}", + "", + "", + "TENSORRT_ONNX_CATALOGS: Dict[str, TensorRTOnnxCatalogInfo] = {", + " TENSORRT_ONNX_DEFAULT_VERSION: {", + ' "tensorrt": TENSORRT_ONNX_DEFAULT_VERSION,', + ' "cuda": ["12.x", "13.x"],', + ' "opset_min": TENSORRT_ONNX_OPSET_MIN,', + ' "opset_max": TENSORRT_ONNX_OPSET_MAX,', + f' "source": {doc.source!r},', + f' "supported_releases": {releases!r},', + ' "ops": TENSORRT_ONNX_OPS,', + " },", + "}", + "", + "", + PYTHON_CATALOG_LOOKUP, + ] + ) + return "\n".join(lines) + + +def render_markdown(catalog: Dict[str, object]) -> str: + ops = catalog["onnx_operators"] + lines = [ + f"# TensorRT layers — {catalog['display_name']}", + "", + f"- CUDA: `{catalog['cuda']}`", + f"- TensorRT: {catalog['tensorrt']}", + f"- Arch: {catalog['arch']} (CC {catalog['compute_capability']})", + f"- Parser table: TensorRT {catalog['parser_tensorrt_version']}, " + f"opset {catalog['opset']['min']}-{catalog['opset']['max']}", + f"- GPU precisions: {', '.join(catalog['gpu_precisions'])}", + f"- DLA: {catalog['dla']}", + f"- Supported releases: {', '.join(catalog.get('supported_releases') or []) or '(unspecified)'}", + "", + "## Notes", + "", + ] + for note in catalog["notes"]: + lines.append(f"- {note}") + nvinfer_info = catalog.get("nvinfer") or {} + header_sources = nvinfer_info.get("source") or [] + if header_sources: + lines.extend(["", "## TensorRT headers", ""]) + for src in header_sources: + lines.append(f"- `{src}`") + if nvinfer_info.get("strongly_typed_note"): + lines.append(f"- {nvinfer_info['strongly_typed_note']}") + lines.extend(["", "## ONNX operators (supported)", "", "| Operator | Types | nvinfer DataType | Restrictions |", "|---|---|---|---|"]) + for name, info in ops.items(): + if not info["supported"]: + continue + types = ", ".join(info["types"]) + nvinfer = ", ".join(info.get("nvinfer_datatypes") or []) + restrictions = str(info["restrictions"]).replace("|", "\\|") + lines.append(f"| {name} | {types} | {nvinfer} | {restrictions} |") + lines.extend(["", "## ONNX operators (unsupported)", "", "| Operator | Restrictions |", "|---|---|"]) + for name, info in ops.items(): + if info["supported"]: + continue + restrictions = str(info["restrictions"]).replace("|", "\\|") + lines.append(f"| {name} | {restrictions} |") + lines.extend(["", "## Native TensorRT layers", "", "| Layer | GPU | DLA | Notes |", "|---|---|---|---|"]) + for name, info in catalog["tensorrt_layers"].items(): + notes = str(info["notes"]).replace("|", "\\|") + lines.append(f"| {name} | {info['gpu']} | {info['dla']} | {notes} |") + lines.append("") + return "\n".join(lines) + + +def _release_sort_key(tag: str) -> tuple: + body = normalize_release_tag(tag).lstrip("vV") + parts = [] + for piece in re.split(r"[.-]", body): + parts.append(int(piece) if piece.isdigit() else 0) + return tuple(parts) + + +def sort_release_tags(tags: Sequence[str]) -> List[str]: + unique: List[str] = [] + seen = set() + for tag in tags: + normalized = normalize_release_tag(tag) + if normalized not in seen: + seen.add(normalized) + unique.append(normalized) + return sorted(unique, key=_release_sort_key) + + +def infer_supported_releases( + doc: OperatorsDoc, + releases: Sequence[str] = (), +) -> List[str]: + if releases: + return sort_release_tags(releases) + if doc.tensorrt_version and doc.tensorrt_version != "unknown": + return [normalize_release_tag(doc.tensorrt_version)] + return [] + + +def catalog_fingerprint( + doc: OperatorsDoc, + headers: Optional[TensorRTHeaderCatalog], +) -> tuple: + ops = tuple( + (op.name, op.supported, tuple(op.types), op.restrictions) for op in doc.ops + ) + if headers is None: + header_key = None + else: + header_key = ( + tuple(headers.data_types), + tuple(headers.layer_types), + tuple(headers.builder_flags), + tuple(headers.network_definition_creation_flags), + ) + return (ops, header_key) + + +def database_id(releases: Sequence[str]) -> str: + ordered = sort_release_tags(releases) + return ordered[-1] if ordered else "untagged" + + +def write_catalogs( + output_dir: Path, + catalogs: Iterable[Dict[str, object]], + *, + formats: Sequence[str] = ("json", "md"), + extra_index: Optional[Dict[str, object]] = None, +) -> List[Path]: + catalog_list = list(catalogs) + output_dir.mkdir(parents=True, exist_ok=True) + written: List[Path] = [] + for catalog in catalog_list: + stem = f"tensorrt_layers_cuda{catalog['cuda'].replace('.', '')}_{catalog['platform']}" + if "json" in formats: + path = output_dir / f"{stem}.json" + path.write_text(json.dumps(catalog, indent=2) + "\n", encoding="utf-8") + written.append(path) + if "md" in formats: + path = output_dir / f"{stem}.md" + path.write_text(render_markdown(catalog), encoding="utf-8") + written.append(path) + index: Dict[str, object] = { + "cuda": TARGET_CUDA, + "platforms": [catalog["platform"] for catalog in catalog_list], + "supported_releases": list(catalog_list[0].get("supported_releases") or []) + if catalog_list + else [], + "files": [str(path.name) for path in written], + } + if extra_index: + index.update(extra_index) + index_path = output_dir / "index.json" + index_path.write_text(json.dumps(index, indent=2) + "\n", encoding="utf-8") + written.append(index_path) + return written + + +def _load_headers_for_release( + *, + tag: Optional[str], + include_dir: Optional[str], + fetch_headers: bool, + headers: Optional[TensorRTHeaderCatalog], + headers_by_release: Optional[Dict[str, TensorRTHeaderCatalog]], +) -> Optional[TensorRTHeaderCatalog]: + if headers_by_release is not None: + if tag is None: + return headers + return headers_by_release.get(tag) or headers_by_release.get( + normalize_release_tag(tag) + ) + if headers is not None: + return headers + if include_dir: + return load_tensorrt_headers(include_dir=include_dir, fetch=False) + if tag: + return load_tensorrt_headers(ref=tag, fetch=True) + if fetch_headers: + return load_tensorrt_headers(fetch=True) + return None + + +def generate( + *, + platforms: Sequence[str] = DEFAULT_PLATFORMS, + operators_md: Optional[str] = None, + operators_url: str = DEFAULT_OPERATORS_MD_URL, + output_dir: Optional[Path] = None, + formats: Sequence[str] = ("json", "md"), + write_python: Optional[Path] = None, + include_dir: Optional[str] = None, + fetch_headers: bool = False, + headers: Optional[TensorRTHeaderCatalog] = None, + releases: Sequence[str] = (), + headers_by_release: Optional[Dict[str, TensorRTHeaderCatalog]] = None, +) -> Dict[str, object]: + platforms = [resolve_platform_name(name) for name in platforms] + unknown = [name for name in platforms if name not in PLATFORMS] + if unknown: + raise ValueError(f"Unknown platforms {unknown}; choose from {sorted(PLATFORMS)}") + requested = [normalize_release_tag(tag) for tag in releases] if releases else [None] + groups: Dict[tuple, Dict[str, object]] = {} + group_order: List[tuple] = [] + for tag in requested: + doc = load_operators_md(path=operators_md, url=operators_url) + header_catalog = _load_headers_for_release( + tag=tag, + include_dir=include_dir, + fetch_headers=fetch_headers, + headers=headers, + headers_by_release=headers_by_release, + ) + fingerprint = catalog_fingerprint(doc, header_catalog) + if fingerprint not in groups: + groups[fingerprint] = { + "doc": doc, + "headers": header_catalog, + "releases": [], + } + group_order.append(fingerprint) + if tag is not None: + groups[fingerprint]["releases"].append(tag) + + databases = [] + for fingerprint in group_order: + group = groups[fingerprint] + doc = group["doc"] + header_catalog = group["headers"] + supported = infer_supported_releases(doc, group["releases"]) + db_id = database_id(supported) if supported else "untagged" + platform_catalogs = [ + build_platform_catalog( + doc, + PLATFORMS[name], + headers=header_catalog, + supported_releases=supported, + ) + for name in platforms + ] + databases.append( + { + "id": db_id, + "supported_releases": supported, + "operators_doc": doc, + "doc": { + "tensorrt_version": doc.tensorrt_version, + "opset_min": doc.opset_min, + "opset_max": doc.opset_max, + "source": doc.source, + "op_count": len(doc.ops), + "headers": None + if header_catalog is None + else header_catalog.source, + }, + "catalogs": platform_catalogs, + } + ) + + written: List[Path] = [] + if output_dir is not None: + output_dir = Path(output_dir) + if len(databases) <= 1: + catalogs = databases[0]["catalogs"] if databases else [] + extra = { + "databases": [ + { + "id": databases[0]["id"], + "supported_releases": databases[0]["supported_releases"], + } + ] + if databases + else [], + "release_to_database": { + tag: databases[0]["id"] + for tag in databases[0]["supported_releases"] + } + if databases + else {}, + } + written = write_catalogs( + output_dir, catalogs, formats=formats, extra_index=extra + ) + else: + release_to_db = {} + db_index = [] + for database in databases: + subdir = output_dir / database["id"] + files = write_catalogs(subdir, database["catalogs"], formats=formats) + written.extend(files) + db_index.append( + { + "id": database["id"], + "supported_releases": database["supported_releases"], + "dir": database["id"], + } + ) + for tag in database["supported_releases"]: + release_to_db[tag] = database["id"] + index_path = output_dir / "index.json" + index_path.write_text( + json.dumps( + { + "cuda": TARGET_CUDA, + "databases": db_index, + "release_to_database": release_to_db, + }, + indent=2, + ) + + "\n", + encoding="utf-8", + ) + written.append(index_path) + + python_path = None + if write_python is not None and databases: + canonical = databases[-1] + write_python.parent.mkdir(parents=True, exist_ok=True) + write_python.write_text( + render_python_catalog( + canonical["operators_doc"], + supported_releases=canonical["supported_releases"], + ), + encoding="utf-8", + ) + python_path = str(write_python) + + primary = databases[-1] if databases else None + return { + "doc": primary["doc"] if primary else {}, + "catalogs": primary["catalogs"] if primary else [], + "databases": databases, + "written": [str(path) for path in written], + "python": python_path, + } diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py new file mode 100644 index 00000000..0cbc3ac2 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py @@ -0,0 +1,118 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Rewrite one ONNX file or a directory of ONNX files for TensorRT.""" + +from __future__ import annotations + +import logging +import os +import shutil +from dataclasses import dataclass, field +from typing import List + +import onnx + +from isaac_deploy_trt.surgery import ( + apply_tensorrt_rewrites, + graph_io_signature, + load_graph, + save_graph, +) + +logger = logging.getLogger(__name__) + + +@dataclass +class RewriteFileResult: + filename: str + rewritten: bool + rewritten_nodes: List[str] = field(default_factory=list) + output_path: str = "" + + +def needs_tensorrt_rewrite(model: onnx.ModelProto) -> bool: + inits = {init.name: init for init in model.graph.initializer} + for node in model.graph.node: + if node.op_type == "Cast": + to_attr = next((a.i for a in node.attribute if a.name == "to"), None) + if to_attr == 2: + return True + if node.op_type == "Resize": + antialias = next((a.i for a in node.attribute if a.name == "antialias"), 0) + if int(antialias) != 0: + return True + if node.op_type == "Reshape" and len(node.input) >= 2: + shape_init = inits.get(node.input[1]) + if shape_init is not None and len(shape_init.dims) == 1 and shape_init.dims[0] > 8: + return True + return False + + +def _copy_with_sidecars(src_onnx: str, dst_onnx: str) -> None: + shutil.copy2(src_onnx, dst_onnx) + src_dir = os.path.dirname(os.path.abspath(src_onnx)) + dst_dir = os.path.dirname(os.path.abspath(dst_onnx)) + stem = os.path.basename(src_onnx) + for name in os.listdir(src_dir): + if name == stem: + continue + if name.startswith(stem + ".") or name == stem + ".data": + shutil.copy2(os.path.join(src_dir, name), os.path.join(dst_dir, name)) + + +def rewrite_onnx_file(src: str, dst: str) -> RewriteFileResult: + """Rewrite ``src`` in place-of-copy at ``dst``. Preserves graph I/O.""" + src = os.path.abspath(src) + dst = os.path.abspath(dst) + os.makedirs(os.path.dirname(dst) or ".", exist_ok=True) + filename = os.path.basename(src) + source_model = onnx.load(src, load_external_data=False) + source_io = graph_io_signature(source_model) + + if not needs_tensorrt_rewrite(source_model): + _copy_with_sidecars(src, dst) + logger.info("Copied %s (no TensorRT GraphSurgeon edits needed)", filename) + return RewriteFileResult( + filename=filename, rewritten=False, output_path=dst + ) + + graph = load_graph(src) + rewritten_nodes = apply_tensorrt_rewrites(graph) + save_graph(graph, dst) + aligned = onnx.load(dst, load_external_data=False) + aligned_io = graph_io_signature(aligned) + if aligned_io != source_io: + raise RuntimeError( + f"TensorRT rewrite changed graph I/O for {filename}: " + f"{source_io} -> {aligned_io}" + ) + logger.info("Rewrote %s (%s node(s))", filename, len(rewritten_nodes)) + return RewriteFileResult( + filename=filename, + rewritten=True, + rewritten_nodes=rewritten_nodes, + output_path=dst, + ) + + +def rewrite_directory(input_dir: str, output_dir: str) -> List[RewriteFileResult]: + """Rewrite every ``*.onnx`` under ``input_dir`` into ``output_dir``.""" + input_dir = os.path.abspath(input_dir) + output_dir = os.path.abspath(output_dir) + if input_dir == output_dir: + raise ValueError("output_dir must differ from input_dir") + os.makedirs(output_dir, exist_ok=True) + results: List[RewriteFileResult] = [] + for name in sorted(os.listdir(input_dir)): + if not name.endswith(".onnx"): + continue + results.append( + rewrite_onnx_file( + os.path.join(input_dir, name), + os.path.join(output_dir, name), + ) + ) + return results diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py new file mode 100644 index 00000000..2ea5bcc6 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py @@ -0,0 +1,646 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""ONNX graph surgery helpers (GraphSurgeon-style edit API). + +Thin wrappers around ``onnx_graphsurgeon`` for common edits used when preparing +models for TensorRT: insert / remove / swap / rename nodes and tensors, and +replace a subgraph with a single node (e.g. a TRT plugin). + +Requires the optional ``onnx-graphsurgeon`` package:: + + pip install onnx-graphsurgeon +""" + +from __future__ import annotations + +from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Union + +import onnx +from onnx import ModelProto + +import logging + +GraphLike = Any # onnx_graphsurgeon.Graph +NodeLike = Any # onnx_graphsurgeon.Node +TensorLike = Any # onnx_graphsurgeon.Tensor + + +def _gs(): + try: + import onnx_graphsurgeon as gs + except ImportError as exc: + raise ImportError( + "onnx-graphsurgeon is required for isaac_deploy_trt. " + "Install with: pip install onnx-graphsurgeon" + ) from exc + return gs + + +def load_graph(model_or_path: Union[str, ModelProto]) -> GraphLike: + """Load an ONNX model path or ``ModelProto`` into a GraphSurgeon graph.""" + gs = _gs() + if isinstance(model_or_path, str): + model = onnx.load(model_or_path, load_external_data=False) + else: + model = model_or_path + return gs.import_onnx(model) + + +def export_model(graph: GraphLike, *, do_cleanup: bool = True) -> ModelProto: + """Export a GraphSurgeon graph to an ONNX ``ModelProto``.""" + gs = _gs() + if do_cleanup: + graph.cleanup().toposort() + return gs.export_onnx(graph) + + +def save_graph( + graph: GraphLike, + path: str, + *, + do_cleanup: bool = True, +) -> str: + """Cleanup/toposort (optional) and save the graph to ``path``.""" + model = export_model(graph, do_cleanup=do_cleanup) + onnx.save(model, path) + return path + + +def cleanup_graph(graph: GraphLike) -> GraphLike: + """Remove dangling nodes/tensors and restore topological order.""" + return graph.cleanup().toposort() + + +def tensor_map(graph: GraphLike) -> Dict[str, TensorLike]: + """Return ``{tensor_name: tensor}`` for the graph.""" + return graph.tensors() + + +def find_nodes( + graph: GraphLike, + *, + name: Optional[str] = None, + op: Optional[str] = None, + predicate: Optional[Callable[[NodeLike], bool]] = None, +) -> List[NodeLike]: + """Find nodes by exact name, op type, and/or predicate.""" + matches: List[NodeLike] = [] + for node in graph.nodes: + if name is not None and node.name != name: + continue + if op is not None and node.op != op: + continue + if predicate is not None and not predicate(node): + continue + matches.append(node) + return matches + + +def get_node(graph: GraphLike, name: str) -> NodeLike: + """Return the unique node with ``name`` or raise ``KeyError``.""" + nodes = find_nodes(graph, name=name) + if not nodes: + raise KeyError(f"No node named {name!r}") + if len(nodes) > 1: + raise KeyError(f"Multiple nodes named {name!r}") + return nodes[0] + + +def insert_node( + graph: GraphLike, + op: str, + inputs: Sequence[Union[str, TensorLike]], + outputs: Optional[Sequence[Union[str, TensorLike]]] = None, + *, + attrs: Optional[Dict[str, Any]] = None, + name: Optional[str] = None, + output_dtype=None, + output_shape=None, +) -> NodeLike: + """Insert a node into ``graph``. + + ``inputs`` / ``outputs`` may be tensor names or GraphSurgeon tensors. + If ``outputs`` is omitted, a single new variable tensor is created. + """ + gs = _gs() + tmap = graph.tensors() + + def _as_tensor(value: Union[str, TensorLike], *, create: bool) -> TensorLike: + if not isinstance(value, str): + return value + if value in tmap: + return tmap[value] + if not create: + raise KeyError(f"Tensor {value!r} not found in graph") + return gs.Variable( + name=value, + dtype=output_dtype, + shape=output_shape, + ) + + input_tensors = [_as_tensor(v, create=False) for v in inputs] + if outputs is None: + out_name = f"{name or op}_out" + output_tensors = [ + gs.Variable(name=out_name, dtype=output_dtype, shape=output_shape) + ] + else: + output_tensors = [_as_tensor(v, create=True) for v in outputs] + + node = gs.Node( + op=op, + name=name or "", + attrs=dict(attrs or {}), + inputs=list(input_tensors), + outputs=list(output_tensors), + ) + graph.nodes.append(node) + return node + + +def remove_nodes( + graph: GraphLike, + *, + names: Optional[Iterable[str]] = None, + ops: Optional[Iterable[str]] = None, + predicate: Optional[Callable[[NodeLike], bool]] = None, + reconnect: bool = False, +) -> int: + """Remove matching nodes from ``graph``. + + Args: + names: Exact node names to remove. + ops: Op types to remove. + predicate: Extra filter; node is removed if it matches any provided + selector and passes the predicate (if given). + reconnect: If True, and a removed node is 1-in/1-out, rewire consumers + of its output to its input (Identity-style bypass). Otherwise + dangling edges are left for ``cleanup_graph``. + + Returns: + Number of nodes removed. + """ + name_set = set(names) if names is not None else None + op_set = set(ops) if ops is not None else None + + def _should_remove(node: NodeLike) -> bool: + matched = False + if name_set is not None and node.name in name_set: + matched = True + if op_set is not None and node.op in op_set: + matched = True + if name_set is None and op_set is None: + matched = True + if not matched: + return False + if predicate is not None and not predicate(node): + return False + return True + + to_remove = [node for node in graph.nodes if _should_remove(node)] + for node in to_remove: + if reconnect and len(node.inputs) == 1 and len(node.outputs) == 1: + inp = node.inputs[0] + out = node.outputs[0] + # Rewire consumers of ``out`` to use ``inp``. + for consumer in list(out.outputs): + consumer.inputs = [inp if t is out else t for t in consumer.inputs] + # Update graph I/O if needed. + graph.outputs = [inp if t is out else t for t in graph.outputs] + out.inputs.clear() + out.outputs.clear() + # Detach node from its tensors. + for tensor in list(node.inputs): + if node in tensor.outputs: + tensor.outputs.remove(node) + for tensor in list(node.outputs): + tensor.inputs.clear() + node.inputs.clear() + node.outputs.clear() + graph.nodes.remove(node) + + return len(to_remove) + + +def swap_node_op( + graph: GraphLike, + node_name: str, + new_op: str, + *, + attrs: Optional[Dict[str, Any]] = None, + clear_attrs: bool = True, + new_name: Optional[str] = None, +) -> NodeLike: + """Change a node's operator type (and optionally attrs / name).""" + node = get_node(graph, node_name) + node.op = new_op + if clear_attrs: + node.attrs.clear() + if attrs: + node.attrs.update(attrs) + if new_name is not None: + node.name = new_name + return node + + +def rename_node(graph: GraphLike, old_name: str, new_name: str) -> NodeLike: + """Rename a node. Raises if ``new_name`` already exists.""" + if find_nodes(graph, name=new_name): + raise ValueError(f"Node name {new_name!r} already exists") + node = get_node(graph, old_name) + node.name = new_name + return node + + +def rename_tensor( + graph: GraphLike, + old_name: str, + new_name: str, + *, + update_graph_io: bool = True, +) -> TensorLike: + """Rename a tensor everywhere it appears. + + GraphSurgeon tensors are referenced by object identity on node edges, so + renaming ``tensor.name`` is sufficient for producer/consumer links. Graph + inputs/outputs are the same objects when ``update_graph_io`` is True. + """ + tmap = graph.tensors() + if old_name not in tmap: + raise KeyError(f"Tensor {old_name!r} not found") + if new_name in tmap and tmap[new_name] is not tmap[old_name]: + raise ValueError(f"Tensor name {new_name!r} already exists") + tensor = tmap[old_name] + tensor.name = new_name + if update_graph_io: + # Inputs/outputs already hold the same tensor objects; name change is + # enough. Keep the flag for API clarity / future-proofing. + _ = graph.inputs, graph.outputs + return tensor + + +def replace_subgraph( + graph: GraphLike, + inputs: Sequence[Union[str, TensorLike]], + outputs: Sequence[Union[str, TensorLike]], + op: str, + *, + attrs: Optional[Dict[str, Any]] = None, + name: Optional[str] = None, +) -> NodeLike: + """Replace the subgraph spanning ``inputs`` → ``outputs`` with one node. + + Mirrors the GraphSurgeon pattern used for TRT plugin substitution: + + 1. Disconnect outputs of each input tensor. + 2. Disconnect inputs of each output tensor. + 3. Insert ``op`` with those inputs/outputs. + 4. Caller should ``cleanup_graph(graph)`` to drop the dangling subgraph. + """ + gs = _gs() + tmap = graph.tensors() + + def _resolve(value: Union[str, TensorLike]) -> TensorLike: + if isinstance(value, str): + if value not in tmap: + raise KeyError(f"Tensor {value!r} not found") + return tmap[value] + return value + + input_tensors = [_resolve(v) for v in inputs] + output_tensors = [_resolve(v) for v in outputs] + + for tensor in input_tensors: + tensor.outputs.clear() + for tensor in output_tensors: + tensor.inputs.clear() + + node = gs.Node( + op=op, + name=name or "", + attrs=dict(attrs or {}), + inputs=list(input_tensors), + outputs=list(output_tensors), + ) + graph.nodes.append(node) + logging.getLogger(__name__).info( + f"Replaced subgraph with {op!r} " + f"(inputs={[t.name for t in input_tensors]}, " + f"outputs={[t.name for t in output_tensors]})" + ) + return node + + +def replace_node_with_plugin( + graph: GraphLike, + node_name: str, + plugin_op: str, + *, + attrs: Optional[Dict[str, Any]] = None, + new_name: Optional[str] = None, +) -> NodeLike: + """Replace a single node in-place with a TensorRT plugin op name. + + Keeps the same input/output tensors; only the op (and attrs) change. + Equivalent to ``swap_node_op`` with a plugin-oriented name. + """ + return swap_node_op( + graph, + node_name, + plugin_op, + attrs=attrs, + clear_attrs=True, + new_name=new_name, + ) + + +# ONNX TensorProto.UINT8 / INT32 +_ONNX_UINT8 = 2 +_ONNX_INT32 = 6 + +# nvinfer1::Dims::MAX_DIMS +TENSORRT_MAX_TENSOR_RANK = 8 + + +def _is_uint8_dtype(dtype) -> bool: + if dtype is None: + return False + if dtype == _ONNX_UINT8: + return True + name = getattr(dtype, "name", None) + if name == "uint8": + return True + return str(dtype) in ("uint8", "") + + +def rewrite_uint8_intermediate_casts( + graph: GraphLike, + *, + target_onnx_dtype: int = _ONNX_INT32, +) -> List[str]: + """Rewrite UINT8 ``Cast`` nodes used as intermediate tensors to INT32. + + TensorRT rejects UINT8 intermediates unless UINT8-quantization import is + enabled (``legalUINT8``). Image preprocess graphs often cast FP32 → UINT8 + then back to FP32 around reshape/gather. INT32 is TRT-legal and matches + values already clipped to ``[0, 255]``. + + Does not change graph inputs/outputs that are already UINT8. + Returns names of rewritten Cast nodes. + """ + import numpy as np + + np_dtype = {6: np.int32, 1: np.float32, 7: np.int64}.get( + target_onnx_dtype, np.int32 + ) + rewritten: List[str] = [] + graph_io_ids = {id(t) for t in list(graph.inputs) + list(graph.outputs)} + + for node in list(graph.nodes): + if node.op != "Cast": + continue + to_attr = node.attrs.get("to") + try: + to_val = int(to_attr) + except (TypeError, ValueError): + continue + if to_val != _ONNX_UINT8: + continue + # Keep UINT8 if this Cast produces a graph I/O tensor. + if any(id(t) in graph_io_ids for t in node.outputs): + continue + + node.attrs["to"] = int(target_onnx_dtype) + stack = list(node.outputs) + seen: set[int] = set() + while stack: + tensor = stack.pop() + tid = id(tensor) + if tid in seen: + continue + seen.add(tid) + if id(tensor) in graph_io_ids: + continue + if _is_uint8_dtype(tensor.dtype) or tensor.dtype is None: + tensor.dtype = np_dtype + for consumer in list(tensor.outputs): + if consumer.op == "Cast": + continue + stack.extend(consumer.outputs) + rewritten.append(node.name or f"Cast_{id(node)}") + + if rewritten: + logging.getLogger(__name__).info( + f"Rewrote UINT8 intermediate Cast(s) to ONNX dtype " + f"{target_onnx_dtype}: {rewritten}" + ) + return rewritten + + +def disable_resize_antialias(graph: GraphLike) -> List[str]: + """Set ``antialias=0`` on every Resize node. + + TensorRT's ONNX parser requires ``antialias == 0`` (``UNSUPPORTED_NODE_ATTR``). + Bicubic Resize in GR00T ``preprocess_video`` is exported with ``antialias=1``. + Clearing it makes the node legal; it can slightly increase aliasing vs + the original PyTorch upsample. + """ + rewritten: List[str] = [] + for node in graph.nodes: + if node.op != "Resize": + continue + antialias = node.attrs.get("antialias", 0) + try: + value = int(antialias) + except (TypeError, ValueError): + continue + if value == 0: + continue + node.attrs["antialias"] = 0 + rewritten.append(node.name or f"Resize_{id(node)}") + if rewritten: + logging.getLogger(__name__).info(f"Disabled Resize antialias on: {rewritten}") + return rewritten + + +def _shifted_axis(axis: int, dropped: Sequence[int]) -> int: + """Index of ``axis`` after the ``dropped`` axes are removed.""" + return axis - sum(1 for d in dropped if d < axis) + + +def _constant_values(tensor: TensorLike) -> Optional[List[int]]: + gs = _gs() + if not isinstance(tensor, gs.Constant): + return None + return [int(v) for v in tensor.values.reshape(-1)] + + +def _plan_axis_drop( + tensor: TensorLike, + dropped: Sequence[int], + plan: List[Any], + depth: int = 0, +) -> bool: + """Collect Transpose perm updates needed to drop ``dropped`` axes of ``tensor``. + + Returns False if any consumer cannot be rewritten safely; callers must then + discard ``plan`` instead of applying it. + """ + if depth > TENSORRT_MAX_TENSOR_RANK: + return False + for consumer in tensor.outputs: + if consumer.op == "Reshape": + # A Reshape target shape is absolute, so removing extent-1 axes from + # its input leaves it valid -- unless a 0 makes it copy input dims. + if len(consumer.inputs) < 2: + return False + values = _constant_values(consumer.inputs[1]) + if values is None or 0 in values: + return False + continue + if consumer.op != "Transpose": + return False + perm = consumer.attrs.get("perm") + if perm is None: + return False + perm = [int(p) for p in perm] + new_perm = [_shifted_axis(p, dropped) for p in perm if p not in dropped] + out_dropped = [j for j, p in enumerate(perm) if p in dropped] + plan.append((consumer, new_perm)) + for out in consumer.outputs: + if not _plan_axis_drop(out, out_dropped, plan, depth + 1): + return False + return True + + +def reduce_reshape_rank_for_tensorrt( + graph: GraphLike, + max_rank: int = TENSORRT_MAX_TENSOR_RANK, +) -> List[str]: + """Drop extent-1 axes from Reshape targets whose rank exceeds ``max_rank``. + + TensorRT tensors are limited to ``TENSORRT_MAX_TENSOR_RANK`` dimensions, so a + Reshape to higher rank fails with ``INVALID_NODE``. Patch-shuffle graphs + (Reshape → Transpose → Reshape, as in GR00T ``preprocess_video``) hit this + with a leading ``1``. Removing extent-1 axes never changes row-major element + order, so consuming Transpose perms are remapped and the result is + numerically identical. + + Skips any Reshape that lacks enough extent-1 axes or feeds an op other than + Transpose / constant-shape Reshape. Returns names of rewritten Reshape nodes. + """ + import numpy as np + + gs = _gs() + rewritten: List[str] = [] + + for node in list(graph.nodes): + if node.op != "Reshape" or len(node.inputs) < 2: + continue + shape_tensor = node.inputs[1] + values = _constant_values(shape_tensor) + if values is None: + continue + excess = len(values) - max_rank + if excess <= 0: + continue + + unit_axes = [i for i, v in enumerate(values) if v == 1] + name = node.name or f"Reshape_{id(node)}" + if len(unit_axes) < excess: + logging.getLogger(__name__).warning( + f"Cannot lower rank of {name}: target shape {values} needs " + f"{excess} fewer axes but has {len(unit_axes)} extent-1 axes" + ) + continue + + dropped = sorted(unit_axes[:excess]) + plan: List[Any] = [] + if not all(_plan_axis_drop(out, dropped, plan) for out in node.outputs): + logging.getLogger(__name__).warning( + f"Cannot lower rank of {name}: a consumer is not a Transpose or " + "constant-shape Reshape" + ) + continue + + keep = set(range(len(values))) - set(dropped) + new_values = np.array( + [v for i, v in enumerate(values) if i in keep], + dtype=shape_tensor.values.dtype, + ) + node.inputs[1] = gs.Constant( + name=f"{shape_tensor.name}_rank{len(new_values)}", values=new_values + ) + for transpose, new_perm in plan: + transpose.attrs["perm"] = new_perm + # Recorded shapes still carry the old rank; let shape inference redo them. + for tensor in list(node.outputs) + [ + out for transpose, _ in plan for out in transpose.outputs + ]: + tensor.shape = None + rewritten.append(name) + + if rewritten: + logging.getLogger(__name__).info( + f"Lowered Reshape rank to <= {max_rank} for TensorRT: {rewritten}" + ) + return rewritten + + +def apply_tensorrt_rewrites(graph: GraphLike) -> List[str]: + """Run all TensorRT GraphSurgeon rewrites. Returns names of edited nodes.""" + rewritten: List[str] = [] + rewritten.extend(rewrite_uint8_intermediate_casts(graph)) + rewritten.extend(disable_resize_antialias(graph)) + rewritten.extend(reduce_reshape_rank_for_tensorrt(graph)) + return rewritten + + +def graph_io_signature(model: ModelProto) -> Dict[str, List[tuple]]: + """Return graph input/output (name, elem_type, dims) for alignment checks.""" + + def _dims(info) -> tuple: + return tuple( + d.dim_value if d.dim_value else (d.dim_param or "?") + for d in info.type.tensor_type.shape.dim + ) + + def _entries(infos) -> List[tuple]: + return [ + (info.name, int(info.type.tensor_type.elem_type), _dims(info)) + for info in infos + ] + + return { + "inputs": _entries(model.graph.input), + "outputs": _entries(model.graph.output), + } + + +def rewrite_onnx_for_tensorrt( + model_or_path: Union[str, ModelProto], + output_path: Optional[str] = None, +) -> ModelProto: + """Apply GraphSurgeon rewrites that unblock TensorRT parse for typical ONNX graphs. + + Currently: UINT8 intermediate Casts → INT32, Resize ``antialias`` → 0, and + Reshape rank > 8 lowered by dropping extent-1 axes. Graph I/O names, dtypes, + and shapes are left unchanged so downstream YAML / Triton bindings stay valid. + """ + graph = load_graph(model_or_path) + apply_tensorrt_rewrites(graph) + if output_path is not None: + save_graph(graph, output_path) + return onnx.load(output_path) + return export_model(graph) + + +def rewrite_uint8_intermediates_in_onnx( + model_or_path: Union[str, ModelProto], + output_path: Optional[str] = None, +) -> ModelProto: + """Load an ONNX model, rewrite UINT8 intermediates, optionally save.""" + return rewrite_onnx_for_tensorrt(model_or_path, output_path=output_path) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py new file mode 100644 index 00000000..5ddddf23 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py @@ -0,0 +1,1175 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""TensorRT ONNX operator support catalogs. + +Versioned by TensorRT release (and compatible CUDA majors). ``TENSORRT_ONNX_OPS`` +is the default catalog's operator map so existing callers stay unchanged. + +Source of truth for the current default (TensorRT 11.2, ONNX opset 9-24): +https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md + +This is a static reference for post-export checks. It is not a live +TensorRT API query and does not guarantee a successful engine build for every +attribute / dtype / shape combination. + +To regenerate this table, or to emit CUDA 13.2 catalogs for x86 / Orin / Thor / +DGX (precision and DLA overlays), run:: + +""" + +from __future__ import annotations + +from typing import Dict, List, Optional, TypedDict + + +class TensorRTOnnxOpInfo(TypedDict): + supported: bool + types: List[str] + restrictions: str + + +class TensorRTOnnxCatalogInfo(TypedDict): + """One TensorRT parser table, including the CUDA/TRT versions it covers.""" + + tensorrt: str + cuda: List[str] + opset_min: int + opset_max: int + source: str + ops: Dict[str, TensorRTOnnxOpInfo] + + +# Default catalog key (TensorRT major.minor). Add more entries to +# ``TENSORRT_ONNX_CATALOGS`` when supporting additional parser tables. +TENSORRT_ONNX_DEFAULT_VERSION = "11.2" + +# Opset range documented alongside the default TensorRT 11.2 operators matrix. +TENSORRT_ONNX_OPSET_MIN = 9 +TENSORRT_ONNX_OPSET_MAX = 24 + +TENSORRT_ONNX_OPS: Dict[str, TensorRTOnnxOpInfo] = { + + "Abs": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Acos": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Acosh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Add": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "AffineGrid": { + "supported": False, + "types": [], + "restrictions": '', + }, + "And": { + "supported": True, + "types": ['BOOL'], + "restrictions": '', + }, + "ArgMax": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "ArgMin": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Asin": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Asinh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Atan": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Atanh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Attention": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT8', 'FP8'], + "restrictions": 'Q, K, V and attn_mask must be 4D. past_key, past_value and nonpad_kv_seqlen inputs unsupported. present_key, present_value and qk_matmul_output outputs unsupported. qk_matmul_output_mode and softcap attributes unsupported. q_num_heads and kv_num_heads via second dim of Q and K/V shapes.', + }, + "AveragePool": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '2D or 3D Pooling only. dilations must be empty or all ones', + }, + "BatchNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Bernoulli": { + "supported": False, + "types": [], + "restrictions": '', + }, + "BitShift": { + "supported": False, + "types": [], + "restrictions": '', + }, + "BitwiseAnd": { + "supported": False, + "types": [], + "restrictions": '', + }, + "BitwiseNot": { + "supported": False, + "types": [], + "restrictions": '', + }, + "BitwiseOr": { + "supported": False, + "types": [], + "restrictions": '', + }, + "BitwiseXor": { + "supported": False, + "types": [], + "restrictions": '', + }, + "BlackmanWindow": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "Cast": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'UINT8', 'BOOL'], + "restrictions": '', + }, + "CastLike": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'UINT8', 'BOOL'], + "restrictions": '', + }, + "Ceil": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Col2Im": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Celu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "CenterCropPad": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Clip": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Compress": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Concat": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "ConcatFromSequence": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Constant": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'FP8', 'FP4', 'INT4', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'sparse_value, value_string, and value_strings attributes unsupported', + }, + "ConstantOfShape": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'FP8', 'FP4', 'INT4', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Conv": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "ConvInteger": { + "supported": False, + "types": [], + "restrictions": '', + }, + "ConvTranspose": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Cos": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Cosh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "CumSum": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'axis must be a build-time constant', + }, + "DFT": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'Runs on cuFFT-backed plugin; complex packed-real [..., 2]; transform axis must be -2; see TensorRT operators.md for full restrictions', + }, + "DeformConv": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": 'input must have 1D or 2D spatial dims; pads begin/end along each spatial axis must match', + }, + "DepthToSpace": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "DequantizeLinear": { + "supported": True, + "types": ['INT8', 'FP8', 'FP4', 'INT4'], + "restrictions": 'x_zero_point must be zero', + }, + "Det": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Div": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Dropout": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'is_training must be an initializer and evaluate to False', + }, + "DynamicQuantizeLinear": { + "supported": False, + "types": [], + "restrictions": ( + "Not supported. TensorRT IDynamicQuantize can be composed " + "from ONNX local functions." + ), + }, + "Einsum": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Elu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Equal": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Erf": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Exp": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Expand": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "EyeLike": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'input must have static dimensions', + }, + "Flatten": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Floor": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Gather": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "GatherElements": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "GatherND": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Gelu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT8', 'INT32', 'INT64'], + "restrictions": '', + }, + "Gemm": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "GlobalAveragePool": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "GlobalLpPool": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "GlobalMaxPool": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Greater": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "GreaterOrEqual": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "GridSample": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'Input must be 4D or 5D', + }, + "GroupNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "GRU": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'For bidirectional GRUs, activation functions must match forward and reverse', + }, + "HammingWindow": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "HannWindow": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "HardSigmoid": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "HardSwish": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Hardmax": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'axis dimension of input must be a build-time constant', + }, + "Identity": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "If": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'Branch outputs must have same rank and different names', + }, + "ImageScaler": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "ImageDecoder": { + "supported": False, + "types": [], + "restrictions": '', + }, + "InstanceNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "IsInf": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "IsNaN": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "LayerNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'Only the first output Y is supported', + }, + "LeakyRelu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Less": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "LessOrEqual": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Log": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "LogSoftmax": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Loop": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'Scan output length cannot be dynamic; carried dependency shapes must be constant across iterations', + }, + "LRN": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "LSTM": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'Bidirectional activations must match; input_forget must be 0; layout must be 0', + }, + "LpNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "LpPool": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'dilations must be empty or all ones', + }, + "MatMul": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "MatMulInteger": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Max": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "MaxPool": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '2D or 3D pooling only; Indices output unsupported; dilations empty or all ones', + }, + "MaxRoiPool": { + "supported": False, + "types": [], + "restrictions": '', + }, + "MaxUnpool": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Mean": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'FP8', 'INT32', 'INT64'], + "restrictions": '', + }, + "MeanVarianceNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "MelWeightMatrix": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Min": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Mish": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "Mod": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Mul": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Multinomial": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Neg": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "NegativeLogLikelihoodLoss": { + "supported": False, + "types": [], + "restrictions": '', + }, + "NonMaxSuppression": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "NonZero": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "Not": { + "supported": True, + "types": ['BOOL'], + "restrictions": '', + }, + "OneHot": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'depth must be a build-time constant', + }, + "Optional": { + "supported": False, + "types": [], + "restrictions": '', + }, + "OptionalGetElement": { + "supported": False, + "types": [], + "restrictions": '', + }, + "OptionalHasElement": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Or": { + "supported": True, + "types": ['BOOL'], + "restrictions": '', + }, + "Pad": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "ParametricSoftplus": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Pow": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "PRelu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "QLinearConv": { + "supported": False, + "types": [], + "restrictions": '', + }, + "QLinearMatMul": { + "supported": False, + "types": [], + "restrictions": '', + }, + "QuantizeLinear": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'y_zero_point must be 0', + }, + "RandomNormal": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'seed value is ignored by TensorRT', + }, + "RandomNormalLike": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'seed value is ignored by TensorRT', + }, + "RandomUniform": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'seed value is ignored by TensorRT', + }, + "RandomUniformLike": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'seed value is ignored by TensorRT', + }, + "Range": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Reciprocal": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "ReduceL1": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceL2": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceLogSum": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceLogSumExp": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceMax": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceMean": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceMin": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceProd": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceSum": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "ReduceSumSquare": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'axes must be an initializer', + }, + "RegexFullMatch": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Relu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Reshape": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Resize": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'See TensorRT operators.md for supported modes and aspect-ratio policy restrictions', + }, + "ReverseSequence": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "RMSNormalization": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "RNN": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'For bidirectional RNNs, activation functions must match forward and reverse', + }, + "RoiAlign": { + "supported": True, + "types": ['FP32', 'FP16'], + "restrictions": '', + }, + "RotaryEmbedding": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'position_ids must be INT64', + }, + "Round": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "STFT": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": 'frame_step and window must be initializers; input must be real-valued', + }, + "ScaledTanh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Scan": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Scatter": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "ScatterElements": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "ScatterND": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'reduction other than none is not supported', + }, + "Selu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "SequenceAt": { + "supported": False, + "types": [], + "restrictions": '', + }, + "SequenceConstruct": { + "supported": False, + "types": [], + "restrictions": '', + }, + "SequenceEmpty": { + "supported": False, + "types": [], + "restrictions": '', + }, + "SequenceErase": { + "supported": False, + "types": [], + "restrictions": '', + }, + "SequenceInsert": { + "supported": False, + "types": [], + "restrictions": '', + }, + "SequenceLength": { + "supported": False, + "types": [], + "restrictions": '', + }, + "SequenceMap": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Shape": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Shrink": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Sigmoid": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Sign": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Sin": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Sinh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Size": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Slice": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Softmax": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "SoftmaxCrossEntropyLoss": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Softplus": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Softsign": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "SpaceToDepth": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Split": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "SplitToSequence": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Sqrt": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Squeeze": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'axes must be resolvable to a constant', + }, + "StringConcat": { + "supported": False, + "types": [], + "restrictions": '', + }, + "StringNormalizer": { + "supported": False, + "types": [], + "restrictions": '', + }, + "StringSplit": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Sub": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Sum": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": '', + }, + "Swish": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Tan": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Tanh": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "TensorScatter": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32'], + "restrictions": 'past_cache and update must be 4D; axis must be -2', + }, + "TfIdfVectorizer": { + "supported": False, + "types": [], + "restrictions": '', + }, + "ThresholdedRelu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Tile": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "TopK": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64'], + "restrictions": 'sorted must be 1; K input must be less than 3840', + }, + "Transpose": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Trilu": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Unique": { + "supported": False, + "types": [], + "restrictions": '', + }, + "Unsqueeze": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": 'axes must be resolvable to a constant', + }, + "Upsample": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16'], + "restrictions": '', + }, + "Where": { + "supported": True, + "types": ['FP32', 'FP16', 'BF16', 'INT32', 'INT64', 'BOOL'], + "restrictions": '', + }, + "Xor": { + "supported": True, + "types": ['BOOL'], + "restrictions": '', + }, +} + + +# Versioned catalogs. ``ops`` for 11.2 is the ``TENSORRT_ONNX_OPS`` map above. +# Future TensorRT/CUDA tables get their own key and operator dict. +TENSORRT_ONNX_CATALOGS: Dict[str, TensorRTOnnxCatalogInfo] = { + TENSORRT_ONNX_DEFAULT_VERSION: { + "tensorrt": TENSORRT_ONNX_DEFAULT_VERSION, + "cuda": ["12.x", "13.x"], + "opset_min": TENSORRT_ONNX_OPSET_MIN, + "opset_max": TENSORRT_ONNX_OPSET_MAX, + "source": ( + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md" + ), + "ops": TENSORRT_ONNX_OPS, + }, +} + + +def _normalize_tensorrt_version(version: str) -> str: + parts = [part for part in str(version).strip().split(".") if part] + if len(parts) >= 2: + return f"{parts[0]}.{parts[1]}" + if parts: + return parts[0] + raise ValueError(f"Invalid TensorRT version: {version!r}") + + +def _cuda_matches(entry: str, requested: str) -> bool: + """Match catalog CUDA tags like ``13.x`` or ``13.2`` against ``13.2``.""" + want = requested.strip().lower() + have = entry.strip().lower() + if have.endswith(".x"): + return want == have[:-2] or want.startswith(have[:-1]) + return want == have or want.startswith(have + ".") + + +def list_onnx_ops_catalogs() -> List[str]: + """Return TensorRT version keys that have an operator catalog.""" + return sorted(TENSORRT_ONNX_CATALOGS) + + +def onnx_ops_catalog( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> TensorRTOnnxCatalogInfo: + """Return a versioned catalog. + + Args: + tensorrt: TensorRT version (``11.2`` or ``11.2.1``). Defaults to + ``TENSORRT_ONNX_DEFAULT_VERSION``. + cuda: If ``tensorrt`` is omitted, pick the latest catalog that lists + this CUDA version (``13.2`` matches ``13.x``). + """ + if tensorrt: + key = _normalize_tensorrt_version(tensorrt) + if key not in TENSORRT_ONNX_CATALOGS: + raise KeyError( + f"No ONNX operator catalog for TensorRT {tensorrt!r} " + f"(have {list_onnx_ops_catalogs()})" + ) + catalog = TENSORRT_ONNX_CATALOGS[key] + if cuda and not any(_cuda_matches(tag, cuda) for tag in catalog["cuda"]): + raise KeyError( + f"TensorRT {key} catalog does not list CUDA {cuda!r} " + f"(have {catalog['cuda']})" + ) + return catalog + + if cuda: + matches = [ + TENSORRT_ONNX_CATALOGS[key] + for key in sorted(TENSORRT_ONNX_CATALOGS, reverse=True) + if any(_cuda_matches(tag, cuda) for tag in TENSORRT_ONNX_CATALOGS[key]["cuda"]) + ] + if not matches: + raise KeyError( + f"No ONNX operator catalog lists CUDA {cuda!r} " + f"(have {list_onnx_ops_catalogs()})" + ) + return matches[0] + + return TENSORRT_ONNX_CATALOGS[TENSORRT_ONNX_DEFAULT_VERSION] + + +def onnx_ops_for_version( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> Dict[str, TensorRTOnnxOpInfo]: + """Return the operator map for a TensorRT/CUDA catalog.""" + return onnx_ops_catalog(tensorrt, cuda=cuda)["ops"] + + +def supported_onnx_ops( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> set[str]: + """Return ONNX op names marked supported=True in the selected catalog.""" + ops = onnx_ops_for_version(tensorrt, cuda=cuda) + return {name for name, info in ops.items() if info["supported"]} + + +def unsupported_onnx_ops( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> set[str]: + """Return ONNX op names marked supported=False in the selected catalog.""" + ops = onnx_ops_for_version(tensorrt, cuda=cuda) + return {name for name, info in ops.items() if not info["supported"]} diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py new file mode 100644 index 00000000..57862aca --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py @@ -0,0 +1,137 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Static TensorRT ONNX op catalog checks (optional TensorRT parse/build).""" + +from __future__ import annotations + +import logging +from dataclasses import dataclass, field +from typing import List, Optional, Sequence + +import onnx + +from isaac_deploy_trt.tensorrt_onnx_ops import onnx_ops_for_version, supported_onnx_ops + +logger = logging.getLogger(__name__) + + +@dataclass +class TensorRTOnnxValidationResult: + onnx_path: str + used_ops: List[str] = field(default_factory=list) + unsupported_ops: List[str] = field(default_factory=list) + unknown_ops: List[str] = field(default_factory=list) + parse_ok: Optional[bool] = None + build_ok: Optional[bool] = None + errors: List[str] = field(default_factory=list) + + @property + def ok(self) -> bool: + if self.errors: + return False + if self.unsupported_ops or self.unknown_ops: + return False + if self.parse_ok is False or self.build_ok is False: + return False + return True + + +def collect_onnx_op_types(onnx_path: str) -> List[str]: + model = onnx.load(onnx_path, load_external_data=False) + return sorted({node.op_type for node in model.graph.node}) + + +def check_onnx_ops_against_tensorrt( + onnx_path: str, + *, + known_supported: Optional[Sequence[str]] = None, + tensorrt: Optional[str] = None, + cuda: Optional[str] = None, +) -> TensorRTOnnxValidationResult: + used_ops = collect_onnx_op_types(onnx_path) + ops_map = onnx_ops_for_version(tensorrt, cuda=cuda) + supported = ( + set(known_supported) + if known_supported is not None + else supported_onnx_ops(tensorrt, cuda=cuda) + ) + catalog = set(ops_map) + unsupported = sorted(op for op in used_ops if op in catalog and op not in supported) + unknown = sorted(op for op in used_ops if op not in catalog) + result = TensorRTOnnxValidationResult( + onnx_path=onnx_path, + used_ops=used_ops, + unsupported_ops=unsupported, + unknown_ops=unknown, + ) + if unsupported: + result.errors.append( + f"ONNX ops not marked supported by TensorRT catalog: {unsupported}" + ) + if unknown: + result.errors.append( + f"ONNX ops not present in TensorRT catalog: {unknown}" + ) + return result + + +def try_tensorrt_build(onnx_path: str, *, build: bool = True) -> TensorRTOnnxValidationResult: + result = TensorRTOnnxValidationResult(onnx_path=onnx_path) + try: + import tensorrt as trt + except ImportError as exc: + result.parse_ok = False + if build: + result.build_ok = False + result.errors.append(f"tensorrt is not installed: {exc}") + return result + + logger_trt = trt.Logger(trt.Logger.WARNING) + builder = trt.Builder(logger_trt) + flags = 1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH) + network = builder.create_network(flags) + parser = trt.OnnxParser(network, logger_trt) + with open(onnx_path, "rb") as handle: + parse_ok = parser.parse(handle.read()) + result.parse_ok = bool(parse_ok) + if not parse_ok: + for i in range(parser.num_errors): + result.errors.append(str(parser.get_error(i))) + result.build_ok = False if build else None + return result + if not build: + return result + engine = builder.build_serialized_network(network, builder.create_builder_config()) + result.build_ok = engine is not None + if engine is None: + result.errors.append("TensorRT build_serialized_network returned None") + return result + + +def validate_onnx_for_tensorrt( + onnx_path: str, + *, + build: bool = False, + strict: bool = False, + tensorrt: Optional[str] = None, + cuda: Optional[str] = None, +) -> TensorRTOnnxValidationResult: + result = check_onnx_ops_against_tensorrt( + onnx_path, tensorrt=tensorrt, cuda=cuda + ) + if build: + built = try_tensorrt_build(onnx_path, build=True) + result.parse_ok = built.parse_ok + result.build_ok = built.build_ok + result.errors.extend(built.errors) + if result.ok: + logger.info("TensorRT catalog check passed for %s", onnx_path) + else: + message = f"TensorRT issues for {onnx_path}: " + "; ".join(result.errors) + if strict: + raise ValueError(message) + logger.warning(message) + return result diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/index.json new file mode 100644 index 00000000..b1b615e8 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/index.json @@ -0,0 +1,85 @@ +{ + "cuda": "13.2", + "databases": [ + { + "id": "v10.7.0", + "supported_releases": [ + "v10.7.0" + ], + "dir": "v10.7.0" + }, + { + "id": "v10.8.0", + "supported_releases": [ + "v10.8.0" + ], + "dir": "v10.8.0" + }, + { + "id": "v10.11", + "supported_releases": [ + "v10.9.0", + "v10.10.0", + "v10.11" + ], + "dir": "v10.11" + }, + { + "id": "v10.13.3", + "supported_releases": [ + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3" + ], + "dir": "v10.13.3" + }, + { + "id": "v10.14", + "supported_releases": [ + "v10.14" + ], + "dir": "v10.14" + }, + { + "id": "v10.15", + "supported_releases": [ + "v10.15" + ], + "dir": "v10.15" + }, + { + "id": "v10.16", + "supported_releases": [ + "v10.16" + ], + "dir": "v10.16" + }, + { + "id": "v11.2", + "supported_releases": [ + "v11.0", + "v11.1", + "v11.2" + ], + "dir": "v11.2" + } + ], + "release_to_database": { + "v10.7.0": "v10.7.0", + "v10.8.0": "v10.8.0", + "v10.9.0": "v10.11", + "v10.10.0": "v10.11", + "v10.11": "v10.11", + "v10.12.0": "v10.13.3", + "v10.13.0": "v10.13.3", + "v10.13.2": "v10.13.3", + "v10.13.3": "v10.13.3", + "v10.14": "v10.14", + "v10.15": "v10.15", + "v10.16": "v10.16", + "v11.0": "v11.2", + "v11.1": "v11.2", + "v11.2": "v11.2" + } +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/index.json new file mode 100644 index 00000000..fb782c4d --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/index.json @@ -0,0 +1,24 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.9.0", + "v10.10.0", + "v10.11" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..092a085b --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3522 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.9.0", + "v10.10.0", + "v10.11" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..946235aa --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,292 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.9.0, v10.10.0, v10.11 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..30fd7451 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3201 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.9.0", + "v10.10.0", + "v10.11" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..efd33d69 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,292 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.9.0, v10.10.0, v10.11 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..4b51f438 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3520 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.9.0", + "v10.10.0", + "v10.11" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..73a480b4 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,291 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.9.0, v10.10.0, v10.11 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..eed5f3e7 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3522 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.9.0", + "v10.10.0", + "v10.11" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..e16f00a0 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.11/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,292 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.9.0, v10.10.0, v10.11 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.9.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/index.json new file mode 100644 index 00000000..a4bd20be --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/index.json @@ -0,0 +1,25 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..fc6b4251 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3525 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..f64c35ab --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,292 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.12.0, v10.13.0, v10.13.2, v10.13.3 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..5c9dfb0d --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3204 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..7ba2a296 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,292 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.12.0, v10.13.0, v10.13.2, v10.13.3 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..8e24a34c --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3523 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..caf9c93e --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,291 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.12.0, v10.13.0, v10.13.2, v10.13.3 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..18c81a3e --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3525 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..c5e70eab --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.13.3/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,292 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.12.0, v10.13.0, v10.13.2, v10.13.3 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.12.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/index.json new file mode 100644 index 00000000..4f76c53b --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/index.json @@ -0,0 +1,22 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.14" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..9aef0059 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3536 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.14" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..93c56985 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,294 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.14 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..87b81367 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3215 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.14" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..e2e1205d --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,294 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.14 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..7bb7ed51 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3534 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.14" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..041f9ca8 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,293 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.14 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..9a29d34c --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3536 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.14" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..768b3026 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.14/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,294 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.14 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.14/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/index.json new file mode 100644 index 00000000..83ca7b13 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/index.json @@ -0,0 +1,22 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.15" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..e3c9c41a --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3550 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.15" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ROTARY_EMBEDDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "KVCACHE_UPDATE": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..ad519984 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,296 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.15 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | +| ROTARY_EMBEDDING | True | False | | +| KVCACHE_UPDATE | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..024c70d1 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3229 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.15" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ROTARY_EMBEDDING": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "KVCACHE_UPDATE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..da58bfac --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,296 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.15 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ROTARY_EMBEDDING | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| KVCACHE_UPDATE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..4967ab8a --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3548 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.15" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ROTARY_EMBEDDING": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "KVCACHE_UPDATE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..6e39fd2e --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,295 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.15 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ROTARY_EMBEDDING | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| KVCACHE_UPDATE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..e3760452 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3550 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.15" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ROTARY_EMBEDDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "KVCACHE_UPDATE": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..9da5eca6 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.15/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,296 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.15 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.15/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | +| ROTARY_EMBEDDING | True | False | | +| KVCACHE_UPDATE | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/index.json new file mode 100644 index 00000000..ef51ec31 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/index.json @@ -0,0 +1,22 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.16" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..81d889b0 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3564 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.16" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ROTARY_EMBEDDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "KVCACHE_UPDATE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MOE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DIST_COLLECTIVE": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..f431d679 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,298 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.16 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | +| ROTARY_EMBEDDING | True | False | | +| KVCACHE_UPDATE | True | False | | +| MOE | True | False | | +| DIST_COLLECTIVE | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..e81a4a8f --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3243 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.16" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ROTARY_EMBEDDING": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "KVCACHE_UPDATE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "MOE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "DIST_COLLECTIVE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..f17db96a --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,298 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.16 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ROTARY_EMBEDDING | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| KVCACHE_UPDATE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| MOE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| DIST_COLLECTIVE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..36a37b1c --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3562 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.16" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ROTARY_EMBEDDING": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "KVCACHE_UPDATE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "MOE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "DIST_COLLECTIVE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..f95b67c2 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,297 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.16 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ROTARY_EMBEDDING | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| KVCACHE_UPDATE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| MOE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| DIST_COLLECTIVE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..2c72dc24 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3564 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.16" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ROTARY_EMBEDDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "KVCACHE_UPDATE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MOE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DIST_COLLECTIVE": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..205e6175 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.16/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,298 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.16 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.16/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | +| ROTARY_EMBEDDING | True | False | | +| KVCACHE_UPDATE | True | False | | +| MOE | True | False | | +| DIST_COLLECTIVE | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/index.json new file mode 100644 index 00000000..f1fee38e --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/index.json @@ -0,0 +1,22 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.7.0" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..0d94b2b3 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3508 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.7.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..ff16ca0d --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,292 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.7.0 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..bc76c610 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3190 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.7.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..d8068eb9 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,292 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.7.0 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..fadf36ad --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3506 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.7.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..28492344 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,291 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.7.0 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..113753cb --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3508 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.7.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..b6c19932 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.7.0/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,292 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.7.0 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.7.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/index.json new file mode 100644 index 00000000..9abf1345 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/index.json @@ -0,0 +1,22 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v10.8.0" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..ba2b455f --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3518 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.8.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..f59a1d94 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,292 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.8.0 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..6b2a7f2a --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3197 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.8.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..f876eb28 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,292 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v10.8.0 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..ff686eca --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3516 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.8.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..20808caf --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,291 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v10.8.0 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..01345cda --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3518 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v10.8.0" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE" + ], + "builder_flags": [ + "kFP16", + "kINT8", + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kOBEY_PRECISION_CONSTRAINTS", + "kPREFER_PRECISION_CONSTRAINTS", + "kDIRECT_IO", + "kREJECT_EMPTY_ALGORITHMS", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kFP8", + "kERROR_ON_TIMING_CACHE_MISS", + "kBF16", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kWEIGHTLESS", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kINT4", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kFP4", + "kEDITABLE_TIMING_CACHE" + ], + "network_definition_creation_flags": [ + "kEXPLICIT_BATCH", + "kSTRONGLY_TYPED" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..41f10f49 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v10.8.0/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,292 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v10.8.0 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v10.8.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/index.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/index.json new file mode 100644 index 00000000..11fbd959 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/index.json @@ -0,0 +1,24 @@ +{ + "cuda": "13.2", + "platforms": [ + "x86", + "orin", + "thor", + "dgx" + ], + "supported_releases": [ + "v11.0", + "v11.1", + "v11.2" + ], + "files": [ + "tensorrt_layers_cuda132_x86.json", + "tensorrt_layers_cuda132_x86.md", + "tensorrt_layers_cuda132_orin.json", + "tensorrt_layers_cuda132_orin.md", + "tensorrt_layers_cuda132_thor.json", + "tensorrt_layers_cuda132_thor.md", + "tensorrt_layers_cuda132_dgx.json", + "tensorrt_layers_cuda132_dgx.md" + ] +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.json new file mode 100644 index 00000000..be409efc --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.json @@ -0,0 +1,3555 @@ +{ + "cuda": "13.2", + "platform": "dgx", + "display_name": "DGX Spark / DGX Blackwell (CUDA 13.2)", + "tensorrt": "TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86", + "arch": "Blackwell GB10 (Spark) or B200/GB200 (DGX)", + "compute_capability": "10.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13.", + "DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x.", + "Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes.", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/release-notes-11/11.2.1.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v11.0", + "v11.1", + "v11.2" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kDIRECT_IO", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kERROR_ON_TIMING_CACHE_MISS", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ROTARY_EMBEDDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "KVCACHE_UPDATE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MOE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DIST_COLLECTIVE": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.md new file mode 100644 index 00000000..47715f19 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_dgx.md @@ -0,0 +1,298 @@ +# TensorRT layers — DGX Spark / DGX Blackwell (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.15+ (Spark/GB10) or TensorRT 11.x on DGX B200-class x86 +- Arch: Blackwell GB10 (Spark) or B200/GB200 (DGX) (CC 10.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v11.0, v11.1, v11.2 + +## Notes + +- DGX Spark (GB10) is ARM and commonly TensorRT 10.15.x on CUDA 13. +- DGX B200/GB200 x86 can use TensorRT 11.x with CUDA 13.x. +- Use this catalog for Blackwell datacenter/desktop; use 'x86' for Hopper-only boxes. +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | +| ROTARY_EMBEDDING | True | False | | +| KVCACHE_UPDATE | True | False | | +| MOE | True | False | | +| DIST_COLLECTIVE | True | False | | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.json new file mode 100644 index 00000000..c2f9f7a2 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.json @@ -0,0 +1,3234 @@ +{ + "cuda": "13.2", + "platform": "orin", + "display_name": "Jetson Orin (CUDA 13.2 / JetPack 7.2)", + "tensorrt": "TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack)", + "arch": "Ampere GA10B iGPU", + "compute_capability": "8.7", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "INT8", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": true, + "tensorrt_11": false, + "notes": [ + "Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin.", + "No BF16, FP8, or FP4 on Orin.", + "DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA.", + "Orin DLA Softmax is Orin-only (not Xavier)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/dla-layer-restrictions.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v11.0", + "v11.1", + "v11.2" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kDIRECT_IO", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kERROR_ON_TIMING_CACHE_MISS", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "nvinfer_datatypes": [ + "kINT8" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; channel axis only" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192]" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; no grouped/dilated; padding 0" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": true, + "notes": "FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; slope must be a build-time constant" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16]" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; MAX; CHW axes" + }, + "RESIZE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; nearest [1,32], bilinear [1,4]" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Uniform, Per-Channel, ElementWise" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; no batch transpose" + }, + "SLICE": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; 4D; static slicing" + }, + "SOFTMAX": { + "gpu": true, + "dla": true, + "notes": "FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": true, + "notes": "INT8; ABS, SIN, COS, ATAN" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ROTARY_EMBEDDING": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "KVCACHE_UPDATE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "MOE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "DIST_COLLECTIVE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.md new file mode 100644 index 00000000..bbf5a82d --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_orin.md @@ -0,0 +1,298 @@ +# TensorRT layers — Jetson Orin (CUDA 13.2 / JetPack 7.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.x from JetPack (TensorRT 11.2.1 does not support JetPack) +- Arch: Ampere GA10B iGPU (CC 8.7) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, INT8, INT32, INT64, UINT8, BOOL +- DLA: True +- Supported releases: v11.0, v11.1, v11.2 + +## Notes + +- Stay on JetPack TensorRT 10.x for CUDA 13.2 Orin. +- No BF16, FP8, or FP4 on Orin. +- DLA is FP16/INT8 and only for the DLA layer subset; TensorRT 11.x has no DLA. +- Orin DLA Softmax is Orin-only (not Xavier). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, INT8 | kFLOAT, kHALF, kINT8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16 | kFLOAT, kHALF | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16 | kFLOAT, kHALF | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8 | kINT8 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16 | kFLOAT, kHALF | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, INT8, INT32, INT64 | kFLOAT, kHALF, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16 | kFLOAT, kHALF | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16 | kFLOAT, kHALF | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16 | kFLOAT, kHALF | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16 | kFLOAT, kHALF | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16 | kFLOAT, kHALF | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16 | kFLOAT, kHALF | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16 | kFLOAT, kHALF | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16 | kFLOAT, kHALF | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16 | kFLOAT, kHALF | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16 | kFLOAT, kHALF | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16 | kFLOAT, kHALF | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16 | kFLOAT, kHALF | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16 | kFLOAT, kHALF | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, INT32 | kFLOAT, kHALF, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, INT32, INT64 | kFLOAT, kHALF, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, INT32, INT64, BOOL | kFLOAT, kHALF, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | True | FP16, INT8; 2D; ReLU, Sigmoid, TanH, Clipped ReLU, Leaky ReLU | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | True | FP16, INT8; channel axis only | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | True | FP16, INT8; 2D; kernel [1,32]; stride [1,8]; channels [1,8192] | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | True | FP16, INT8; 2D; no grouped/dilated; padding 0 | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | True | FP16, INT8; 2D; Sum, Sub, Product, Max, Min, Div, Pow | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | True | FP16 (INT8 promoted to FP16); window 3/5/7/9; ACROSS_CHANNELS | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | True | FP16, INT8; slope must be a build-time constant | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | True | FP16, INT8; 2D; MAX/AVERAGE; window [1,8]; stride [1,16] | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | True | FP16, INT8; 4D; MAX; CHW axes | +| RESIZE | True | True | FP16, INT8; nearest [1,32], bilinear [1,4] | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | True | FP16, INT8; Uniform, Per-Channel, ElementWise | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | True | FP16, INT8; 4D; no batch transpose | +| SLICE | True | True | FP16, INT8; 4D; static slicing | +| SOFTMAX | True | True | FP16, INT8; Orin DLA only; axis dim <= 1024 in optimized mode | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | True | INT8; ABS, SIN, COS, ATAN | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ROTARY_EMBEDDING | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| KVCACHE_UPDATE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| MOE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| DIST_COLLECTIVE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.json new file mode 100644 index 00000000..624fda59 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.json @@ -0,0 +1,3553 @@ +{ + "cuda": "13.2", + "platform": "thor", + "display_name": "Jetson AGX Thor (CUDA 13.x / JetPack 7.x)", + "tensorrt": "TensorRT 10.13\u201310.15.x from JetPack (not TensorRT 11.2.1)", + "arch": "Blackwell (Thor GPU)", + "compute_capability": "11.0", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "dla": false, + "tensorrt_11": false, + "notes": [ + "JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1.", + "Blackwell enables FP8/FP4; no Orin-style DLA catalog.", + "Engines are not portable to Orin (different SM)." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/api/migration/tensorrt-10x-to-11x-jetson.html", + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v11.0", + "v11.1", + "v11.2" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kDIRECT_IO", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kERROR_ON_TIMING_CACHE_MISS", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified." + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ATTENTION_OUTPUT": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "ROTARY_EMBEDDING": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "KVCACHE_UPDATE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "MOE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + }, + "DIST_COLLECTIVE": { + "gpu": false, + "dla": false, + "notes": "Documented as TensorRT 11.x native layer; not in JetPack 10.x" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.md new file mode 100644 index 00000000..2567cd05 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_thor.md @@ -0,0 +1,297 @@ +# TensorRT layers — Jetson AGX Thor (CUDA 13.x / JetPack 7.x) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13–10.15.x from JetPack (not TensorRT 11.2.1) +- Arch: Blackwell (Thor GPU) (CC 11.0) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL +- DLA: False +- Supported releases: v11.0, v11.1, v11.2 + +## Notes + +- JetPack 7.x ships TensorRT 10.x; NVIDIA documents Thor as unsupported on TensorRT 11.2.1. +- Blackwell enables FP8/FP4; no Orin-style DLA catalog. +- Engines are not portable to Orin (different SM). + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| And | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mish | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NonZero | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Not | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Or | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Xor | BOOL | kBOOL | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Bernoulli | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitShift | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseAnd | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseNot | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseOr | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| BitwiseXor | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Col2Im | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| CenterCropPad | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Compress | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConcatFromSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ConvInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Det | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function.; Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| ImageDecoder | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MatMulInteger | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxRoiPool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MaxUnpool | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| MelWeightMatrix | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Multinomial | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| NegativeLogLikelihoodLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Optional | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalGetElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| OptionalHasElement | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearConv | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| QLinearMatMul | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| RegexFullMatch | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceAt | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceConstruct | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceEmpty | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceErase | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceInsert | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceLength | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SequenceMap | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SoftmaxCrossEntropyLoss | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| SplitToSequence | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringConcat | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringNormalizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| StringSplit | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| TfIdfVectorizer | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | +| Unique | Parser table is TensorRT 11.x; this platform ships TensorRT 10.x. Treat newly added 11.x-only ops as unverified. | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ATTENTION_OUTPUT | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| ROTARY_EMBEDDING | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| KVCACHE_UPDATE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| MOE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | +| DIST_COLLECTIVE | False | False | Documented as TensorRT 11.x native layer; not in JetPack 10.x | diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.json b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.json new file mode 100644 index 00000000..44ade8d4 --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.json @@ -0,0 +1,3555 @@ +{ + "cuda": "13.2", + "platform": "x86", + "display_name": "Linux x86_64 (CUDA 13.2)", + "tensorrt": "TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x)", + "arch": "Ampere / Ada / Hopper / Blackwell dGPU", + "compute_capability": "8.0\u201312.x (SKU-dependent)", + "parser_tensorrt_version": "11.2", + "opset": { + "min": 9, + "max": 24 + }, + "source": "https://raw.githubusercontent.com/onnx/onnx-tensorrt/main/docs/operators.md", + "gpu_precisions": [ + "FP32", + "TF32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT8", + "INT4", + "INT32", + "INT64", + "UINT8", + "BOOL", + "FP64" + ], + "dla": false, + "tensorrt_11": true, + "notes": [ + "ONNX parser coverage matches onnx-tensorrt operators.md.", + "FP8 requires Hopper or newer; FP4 requires Blackwell.", + "BF16 is not available on every Ampere SKU (for example some GA10x).", + "No DLA." + ], + "sources": [ + "https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/support-matrix.html", + "https://github.com/onnx/onnx-tensorrt/blob/main/docs/operators.md", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "supported_releases": [ + "v11.0", + "v11.1", + "v11.2" + ], + "nvinfer": { + "source": [ + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h", + "https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h" + ], + "data_types": [ + "kFLOAT", + "kHALF", + "kINT8", + "kINT32", + "kBOOL", + "kUINT8", + "kFP8", + "kBF16", + "kINT64", + "kINT4", + "kFP4", + "kE8M0" + ], + "layer_types": [ + "kCONVOLUTION", + "kCAST", + "kACTIVATION", + "kPOOLING", + "kLRN", + "kSCALE", + "kSOFTMAX", + "kDECONVOLUTION", + "kCONCATENATION", + "kELEMENTWISE", + "kPLUGIN", + "kUNARY", + "kPADDING", + "kSHUFFLE", + "kREDUCE", + "kTOPK", + "kGATHER", + "kMATRIX_MULTIPLY", + "kRAGGED_SOFTMAX", + "kCONSTANT", + "kIDENTITY", + "kPLUGIN_V2", + "kSLICE", + "kSHAPE", + "kPARAMETRIC_RELU", + "kRESIZE", + "kTRIP_LIMIT", + "kRECURRENCE", + "kITERATOR", + "kLOOP_OUTPUT", + "kSELECT", + "kFILL", + "kQUANTIZE", + "kDEQUANTIZE", + "kCONDITION", + "kCONDITIONAL_INPUT", + "kCONDITIONAL_OUTPUT", + "kSCATTER", + "kEINSUM", + "kASSERTION", + "kONE_HOT", + "kNON_ZERO", + "kGRID_SAMPLE", + "kNMS", + "kREVERSE_SEQUENCE", + "kNORMALIZATION", + "kPLUGIN_V3", + "kSQUEEZE", + "kUNSQUEEZE", + "kCUMULATIVE", + "kDYNAMIC_QUANTIZE", + "kATTENTION_INPUT", + "kATTENTION_OUTPUT", + "kROTARY_EMBEDDING", + "kKVCACHE_UPDATE", + "kMOE", + "kDIST_COLLECTIVE" + ], + "layer_type_names": [ + "CONVOLUTION", + "CAST", + "ACTIVATION", + "POOLING", + "LRN", + "SCALE", + "SOFTMAX", + "DECONVOLUTION", + "CONCATENATION", + "ELEMENTWISE", + "PLUGIN", + "UNARY", + "PADDING", + "SHUFFLE", + "REDUCE", + "TOPK", + "GATHER", + "MATRIX_MULTIPLY", + "RAGGED_SOFTMAX", + "CONSTANT", + "IDENTITY", + "PLUGIN_V2", + "SLICE", + "SHAPE", + "PARAMETRIC_RELU", + "RESIZE", + "TRIP_LIMIT", + "RECURRENCE", + "ITERATOR", + "LOOP_OUTPUT", + "SELECT", + "FILL", + "QUANTIZE", + "DEQUANTIZE", + "CONDITION", + "CONDITIONAL_INPUT", + "CONDITIONAL_OUTPUT", + "SCATTER", + "EINSUM", + "ASSERTION", + "ONE_HOT", + "NON_ZERO", + "GRID_SAMPLE", + "NMS", + "REVERSE_SEQUENCE", + "NORMALIZATION", + "PLUGIN_V3", + "SQUEEZE", + "UNSQUEEZE", + "CUMULATIVE", + "DYNAMIC_QUANTIZE", + "ATTENTION_INPUT", + "ATTENTION_OUTPUT", + "ROTARY_EMBEDDING", + "KVCACHE_UPDATE", + "MOE", + "DIST_COLLECTIVE" + ], + "builder_flags": [ + "kDEBUG", + "kGPU_FALLBACK", + "kREFIT", + "kDISABLE_TIMING_CACHE", + "kTF32", + "kSPARSE_WEIGHTS", + "kSAFETY_SCOPE", + "kDIRECT_IO", + "kVERSION_COMPATIBLE", + "kEXCLUDE_LEAN_RUNTIME", + "kERROR_ON_TIMING_CACHE_MISS", + "kDISABLE_COMPILATION_CACHE", + "kSTRIP_PLAN", + "kREFIT_IDENTICAL", + "kWEIGHT_STREAMING", + "kREFIT_INDIVIDUAL", + "kSTRICT_NANS", + "kMONITOR_MEMORY", + "kEDITABLE_TIMING_CACHE", + "kDISTRIBUTIVE_INDEPENDENCE" + ], + "network_definition_creation_flags": [ + "kSTRONGLY_TYPED", + "kPREFER_JIT_PYTHON_PLUGINS", + "kPREFER_AOT_PYTHON_PLUGINS" + ], + "strongly_typed": true, + "strongly_typed_flag": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED", + "strongly_typed_note": "NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types.", + "onnx_type_to_nvinfer": { + "FP32": "kFLOAT", + "FLOAT32": "kFLOAT", + "FLOAT": "kFLOAT", + "FP16": "kHALF", + "FLOAT16": "kHALF", + "BF16": "kBF16", + "BFLOAT16": "kBF16", + "FP8": "kFP8", + "FP4": "kFP4", + "FP64": "kDOUBLE", + "DOUBLE": "kDOUBLE", + "INT8": "kINT8", + "INT4": "kINT4", + "INT32": "kINT32", + "INT64": "kINT64", + "UINT8": "kUINT8", + "BOOL": "kBOOL", + "TF32": "kFLOAT" + } + }, + "onnx_supported": [ + "Abs", + "Acos", + "Acosh", + "Add", + "And", + "ArgMax", + "ArgMin", + "Asin", + "Asinh", + "Atan", + "Atanh", + "Attention", + "AveragePool", + "BatchNormalization", + "BlackmanWindow", + "Cast", + "CastLike", + "Ceil", + "Celu", + "Clip", + "Concat", + "Constant", + "ConstantOfShape", + "Conv", + "ConvTranspose", + "Cos", + "Cosh", + "CumSum", + "DFT", + "DeformConv", + "DepthToSpace", + "DequantizeLinear", + "Div", + "Dropout", + "Einsum", + "Elu", + "Equal", + "Erf", + "Exp", + "Expand", + "EyeLike", + "Flatten", + "Floor", + "Gather", + "GatherElements", + "GatherND", + "Gelu", + "Gemm", + "GlobalAveragePool", + "GlobalLpPool", + "GlobalMaxPool", + "Greater", + "GreaterOrEqual", + "GridSample", + "GroupNormalization", + "GRU", + "HammingWindow", + "HannWindow", + "HardSigmoid", + "HardSwish", + "Hardmax", + "Identity", + "If", + "ImageScaler", + "InstanceNormalization", + "IsInf", + "IsNaN", + "LayerNormalization", + "LeakyRelu", + "Less", + "LessOrEqual", + "Log", + "LogSoftmax", + "Loop", + "LRN", + "LSTM", + "LpNormalization", + "LpPool", + "MatMul", + "Max", + "MaxPool", + "Mean", + "MeanVarianceNormalization", + "Min", + "Mish", + "Mod", + "Mul", + "Neg", + "NonMaxSuppression", + "NonZero", + "Not", + "OneHot", + "Or", + "Pad", + "ParametricSoftplus", + "Pow", + "PRelu", + "QuantizeLinear", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + "Range", + "Reciprocal", + "ReduceL1", + "ReduceL2", + "ReduceLogSum", + "ReduceLogSumExp", + "ReduceMax", + "ReduceMean", + "ReduceMin", + "ReduceProd", + "ReduceSum", + "ReduceSumSquare", + "Relu", + "Reshape", + "Resize", + "ReverseSequence", + "RMSNormalization", + "RNN", + "RoiAlign", + "RotaryEmbedding", + "Round", + "STFT", + "ScaledTanh", + "Scan", + "Scatter", + "ScatterElements", + "ScatterND", + "Selu", + "Shape", + "Shrink", + "Sigmoid", + "Sign", + "Sin", + "Sinh", + "Size", + "Slice", + "Softmax", + "Softplus", + "Softsign", + "SpaceToDepth", + "Split", + "Sqrt", + "Squeeze", + "Sub", + "Sum", + "Swish", + "Tan", + "Tanh", + "TensorScatter", + "ThresholdedRelu", + "Tile", + "TopK", + "Transpose", + "Trilu", + "Unsqueeze", + "Upsample", + "Where", + "Xor" + ], + "onnx_unsupported": [ + "AffineGrid", + "Bernoulli", + "BitShift", + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "Col2Im", + "CenterCropPad", + "Compress", + "ConcatFromSequence", + "ConvInteger", + "Det", + "DynamicQuantizeLinear", + "ImageDecoder", + "MatMulInteger", + "MaxRoiPool", + "MaxUnpool", + "MelWeightMatrix", + "Multinomial", + "NegativeLogLikelihoodLoss", + "Optional", + "OptionalGetElement", + "OptionalHasElement", + "QLinearConv", + "QLinearMatMul", + "RegexFullMatch", + "SequenceAt", + "SequenceConstruct", + "SequenceEmpty", + "SequenceErase", + "SequenceInsert", + "SequenceLength", + "SequenceMap", + "SoftmaxCrossEntropyLoss", + "SplitToSequence", + "StringConcat", + "StringNormalizer", + "StringSplit", + "TfIdfVectorizer", + "Unique" + ], + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "FP8" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kFP8" + ], + "restrictions": "`Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively." + }, + "AveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D Pooling only. `dilations` must be empty or all ones" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitShift": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseNot": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseOr": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BitwiseXor": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "UINT8", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kUINT8", + "kBOOL" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Clip": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Compress": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Concat": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Constant": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`sparse_value`, `value_string`, and `value_strings` attributes are unsupported." + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "FP4", + "INT4", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kFP4", + "kINT4", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` must be a build-time constant" + }, + "DFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths." + }, + "DeformConv": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "`input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8", + "FP8", + "FP4", + "INT4" + ], + "nvinfer_datatypes": [ + "kINT8", + "kFP8", + "kFP4", + "kINT4" + ], + "restrictions": "`x_zero_point` must be zero" + }, + "Det": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Div": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`is_training` must be an initializer and evaluate to False." + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function." + }, + "Einsum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`input` must have static dimensions" + }, + "Flatten": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Input must be 4D or 5D." + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`axis` dimension of input must be a build-time constant" + }, + "Identity": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Output tensors of the two conditional branches must have the same rank and must have different names" + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Only the first output `Y` is supported." + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations." + }, + "LRN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0." + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`dilations` must be empty or all ones" + }, + "MatMul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Max": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "MaxUnpool": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Mean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "FP8", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kFP8", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Min": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Neg": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`depth` must be a build-time constant" + }, + "Optional": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`y_zero_point` must be 0" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`seed` value is ignored by TensorRT" + }, + "Range": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`axes` must be an initializer" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Relu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported." + }, + "ReverseSequence": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP32", + "FP16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`position_ids` must be INT64" + }, + "Round": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "`frame_step` and `window` must be an initializer. Input must be real-valued." + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`reduction` other than `none` is not supported" + }, + "Selu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceErase": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceInsert": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceLength": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "SequenceMap": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Shape": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Softplus": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sqrt": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "StringConcat": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringNormalizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "StringSplit": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Sub": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32" + ], + "restrictions": "`past_cache` and `update` must be 4D. `axis` must be -2." + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64" + ], + "restrictions": "`sorted` must be 1. `K` input must be less than 3840." + }, + "Transpose": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "nvinfer_datatypes": [], + "restrictions": "" + }, + "Unsqueeze": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "`axes` must be resolvable to a constant." + }, + "Upsample": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "FP32", + "FP16", + "BF16", + "INT32", + "INT64", + "BOOL" + ], + "nvinfer_datatypes": [ + "kFLOAT", + "kHALF", + "kBF16", + "kINT32", + "kINT64", + "kBOOL" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "nvinfer_datatypes": [ + "kBOOL" + ], + "restrictions": "" + } + }, + "tensorrt_layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DYNAMIC_QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "" + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "" + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "" + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "" + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "" + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "" + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_INPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ATTENTION_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "" + }, + "ROTARY_EMBEDDING": { + "gpu": true, + "dla": false, + "notes": "" + }, + "KVCACHE_UPDATE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "MOE": { + "gpu": true, + "dla": false, + "notes": "" + }, + "DIST_COLLECTIVE": { + "gpu": true, + "dla": false, + "notes": "" + } + }, + "installed_tensorrt": null +} diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.md b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.md new file mode 100644 index 00000000..f116442e --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.md @@ -0,0 +1,298 @@ +# TensorRT layers — Linux x86_64 (CUDA 13.2) + +- CUDA: `13.2` +- TensorRT: TensorRT 10.13+ or 11.x (11.2.1 packages built against CUDA 13.3, compatible with CUDA 13.x) +- Arch: Ampere / Ada / Hopper / Blackwell dGPU (CC 8.0–12.x (SKU-dependent)) +- Parser table: TensorRT 11.2, opset 9-24 +- GPU precisions: FP32, TF32, FP16, BF16, FP8, FP4, INT8, INT4, INT32, INT64, UINT8, BOOL, FP64 +- DLA: False +- Supported releases: v11.0, v11.1, v11.2 + +## Notes + +- ONNX parser coverage matches onnx-tensorrt operators.md. +- FP8 requires Hopper or newer; FP4 requires Blackwell. +- BF16 is not available on every Ampere SKU (for example some GA10x). +- No DLA. + +## TensorRT headers + +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntimeBase.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInfer.h` +- `https://raw.githubusercontent.com/NVIDIA/TensorRT/v11.0/include/NvInferRuntime.h` +- NetworkDefinitionCreationFlag::kSTRONGLY_TYPED (TensorRT 11: always on; the flag is retained for API compatibility). Tensor DataType is authoritative; TensorRT will not implicitly cast. Listed nvinfer_datatypes must match the ONNX/TRT tensor types. + +## ONNX operators (supported) + +| Operator | Types | nvinfer DataType | Restrictions | +|---|---|---|---| +| Abs | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Acos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Acosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Add | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| And | BOOL | kBOOL | | +| ArgMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ArgMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Asin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Asinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Atanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Attention | FP32, FP16, BF16, INT8, FP8 | kFLOAT, kHALF, kBF16, kINT8, kFP8 | `Q`, `K`, `V` and `attn_mask ` must be 4D. `past_key`, `past_value` and `nonpad_kv_seqlen` inputs are unsupported. `present_key`, `present_value` and `qk_matmul_output` outputs are unsupported. `qk_matmul_output_mode` and `softcap` attributes are unsupported. `q_num_heads` and `kv_num_heads` attributes are supported via being specified as the second dimension of `Q` and `K`/`V`'s shapes respectively. | +| AveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D Pooling only. `dilations` must be empty or all ones | +| BatchNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| BlackmanWindow | FP32, FP16 | kFLOAT, kHALF | | +| Cast | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| CastLike | FP32, FP16, BF16, INT32, INT64, UINT8, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kUINT8, kBOOL | | +| Ceil | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Celu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Clip | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Concat | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Constant | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | `sparse_value`, `value_string`, and `value_strings` attributes are unsupported. | +| ConstantOfShape | FP32, FP16, BF16, FP8, FP4, INT4, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kFP8, kFP4, kINT4, kINT32, kINT64, kBOOL | | +| Conv | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ConvTranspose | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cos | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Cosh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| CumSum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` must be a build-time constant | +| DFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Runs on a cuFFT-backed plugin so cuFFT must be available at runtime. Complex tensors use the packed-real `[..., 2]` layout, and the innermost dimension must be a static 1 (real) or 2 (complex). The transform axis must be `-2`. The opset 20 `axis` input must be a build-time constant scalar. `dft_length` is required for the onesided inverse (C2R) and unsupported otherwise. FP16 and BF16 require power-of-two signal lengths. | +| DeformConv | FP32, FP16 | kFLOAT, kHALF | `input` must have 1D or 2D spatial dimensions. `pads` for the beginning and end along each spatial axis must be the same | +| DepthToSpace | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| DequantizeLinear | INT8, FP8, FP4, INT4 | kINT8, kFP8, kFP4, kINT4 | `x_zero_point` must be zero | +| Div | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Dropout | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `is_training` must be an initializer and evaluate to False. | +| Einsum | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Elu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Equal | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Erf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Exp | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Expand | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| EyeLike | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `input` must have static dimensions | +| Flatten | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Floor | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Gather | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherElements | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| GatherND | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Gelu | FP32, FP16, BF16, INT8, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT8, kINT32, kINT64 | | +| Gemm | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalAveragePool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalLpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GlobalMaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Greater | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GreaterOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| GridSample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Input must be 4D or 5D. | +| GroupNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| GRU | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional GRUs, activation functions must be the same for both the forward and reverse pass | +| HammingWindow | FP32, FP16 | kFLOAT, kHALF | | +| HannWindow | FP32, FP16 | kFLOAT, kHALF | | +| HardSigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| HardSwish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Hardmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `axis` dimension of input must be a build-time constant | +| Identity | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| If | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Output tensors of the two conditional branches must have the same rank and must have different names | +| ImageScaler | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| InstanceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsInf | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| IsNaN | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LayerNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Only the first output `Y` is supported. | +| LeakyRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Less | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| LessOrEqual | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Log | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LogSoftmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Loop | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | Scan output length cannot be dynamic. The shape of Loop carried dependencies must be the same across all loop iterations. | +| LRN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LSTM | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional LSTMs, activation functions must be the same for both the forward and reverse pass. `input_forget` attribute must be 0. `layout` attribute must be 0. | +| LpNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| LpPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `dilations` must be empty or all ones | +| MatMul | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Max | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| MaxPool | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | 2D or 3D pooling only. `Indices` output tensor unsupported. `dilations` must be empty or all ones | +| Mean | FP32, FP16, BF16, FP8, INT32, INT64 | kFLOAT, kHALF, kBF16, kFP8, kINT32, kINT64 | | +| MeanVarianceNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Min | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mish | FP32, FP16 | kFLOAT, kHALF | | +| Mod | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Mul | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Neg | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| NonMaxSuppression | FP32, FP16 | kFLOAT, kHALF | | +| NonZero | FP32, FP16 | kFLOAT, kHALF | | +| Not | BOOL | kBOOL | | +| OneHot | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `depth` must be a build-time constant | +| Or | BOOL | kBOOL | | +| Pad | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ParametricSoftplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Pow | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| PRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| QuantizeLinear | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `y_zero_point` must be 0 | +| RandomNormal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomNormalLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniform | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| RandomUniformLike | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `seed` value is ignored by TensorRT | +| Range | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reciprocal | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| ReduceL1 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceL2 | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceLogSumExp | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMax | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMean | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceMin | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceProd | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| ReduceSumSquare | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `axes` must be an initializer | +| Relu | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Reshape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Resize | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | Supported resize transformation modes: `half_pixel`, `pytorch_half_pixel`, `tf_half_pixel_for_nn`, `asymmetric`, and `align_corners`.
Supported resize modes: `nearest`, `linear`.
Supported nearest modes: `floor`, `ceil`, `round_prefer_floor`, `round_prefer_ceil`.
Supported aspect ratio policy: `stretch`.
When `scales` is a tensor input, `axes` must be an iota vector of length rank(input).
Antialiasing is not supported. | +| ReverseSequence | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| RMSNormalization | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| RNN | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | For bidirectional RNNs, activation functions must be the same for both the forward and reverse pass | +| RoiAlign | FP32, FP16 | kFLOAT, kHALF | | +| RotaryEmbedding | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `position_ids` must be INT64 | +| Round | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| STFT | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | `frame_step` and `window` must be an initializer. Input must be real-valued. | +| ScaledTanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Scatter | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterElements | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| ScatterND | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `reduction` other than `none` is not supported | +| Selu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Shape | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Shrink | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sigmoid | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sign | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sin | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Sinh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Size | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Slice | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Softmax | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softplus | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Softsign | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| SpaceToDepth | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Split | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Sqrt | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Squeeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Sub | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Sum | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | | +| Swish | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tan | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tanh | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| TensorScatter | FP32, FP16, BF16, INT32 | kFLOAT, kHALF, kBF16, kINT32 | `past_cache` and `update` must be 4D. `axis` must be -2. | +| ThresholdedRelu | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Tile | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| TopK | FP32, FP16, BF16, INT32, INT64 | kFLOAT, kHALF, kBF16, kINT32, kINT64 | `sorted` must be 1. `K` input must be less than 3840. | +| Transpose | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Trilu | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Unsqueeze | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | `axes` must be resolvable to a constant. | +| Upsample | FP32, FP16, BF16 | kFLOAT, kHALF, kBF16 | | +| Where | FP32, FP16, BF16, INT32, INT64, BOOL | kFLOAT, kHALF, kBF16, kINT32, kINT64, kBOOL | | +| Xor | BOOL | kBOOL | | + +## ONNX operators (unsupported) + +| Operator | Restrictions | +|---|---| +| AffineGrid | | +| Bernoulli | | +| BitShift | | +| BitwiseAnd | | +| BitwiseNot | | +| BitwiseOr | | +| BitwiseXor | | +| Col2Im | | +| CenterCropPad | | +| Compress | | +| ConcatFromSequence | | +| ConvInteger | | +| Det | | +| DynamicQuantizeLinear | Not supported. TensorRT's IDynamicQuantize can be composed from ONNX operators in the form of a model local function. | +| ImageDecoder | | +| MatMulInteger | | +| MaxRoiPool | | +| MaxUnpool | | +| MelWeightMatrix | | +| Multinomial | | +| NegativeLogLikelihoodLoss | | +| Optional | | +| OptionalGetElement | | +| OptionalHasElement | | +| QLinearConv | | +| QLinearMatMul | | +| RegexFullMatch | | +| SequenceAt | | +| SequenceConstruct | | +| SequenceEmpty | | +| SequenceErase | | +| SequenceInsert | | +| SequenceLength | | +| SequenceMap | | +| SoftmaxCrossEntropyLoss | | +| SplitToSequence | | +| StringConcat | | +| StringNormalizer | | +| StringSplit | | +| TfIdfVectorizer | | +| Unique | | + +## Native TensorRT layers + +| Layer | GPU | DLA | Notes | +|---|---|---|---| +| ACTIVATION | True | False | | +| ASSERTION | True | False | | +| ATTENTION | True | False | | +| CAST | True | False | | +| CONCATENATION | True | False | | +| CONDITION | True | False | | +| CONSTANT | True | False | | +| CONVOLUTION | True | False | | +| CUMULATIVE | True | False | | +| DECONVOLUTION | True | False | | +| DEQUANTIZE | True | False | | +| DYNAMIC_QUANTIZE | True | False | | +| EINSUM | True | False | | +| ELEMENTWISE | True | False | | +| FILL | True | False | | +| GATHER | True | False | | +| GRID_SAMPLE | True | False | | +| IDENTITY | True | False | | +| LOOP | True | False | | +| LOOP_OUTPUT | True | False | | +| LRN | True | False | | +| MATRIX_MULTIPLY | True | False | | +| NMS | True | False | | +| NON_ZERO | True | False | | +| NORMALIZATION | True | False | | +| ONE_HOT | True | False | | +| PADDING | True | False | | +| PARAMETRIC_RELU | True | False | | +| PLUGIN | True | False | | +| PLUGIN_V2 | True | False | | +| PLUGIN_V3 | True | False | | +| POOLING | True | False | | +| QUANTIZE | True | False | | +| RAGGED_SOFTMAX | True | False | | +| RECURRENCE | True | False | | +| REDUCE | True | False | | +| RESIZE | True | False | | +| REVERSE_SEQUENCE | True | False | | +| SCALE | True | False | | +| SCATTER | True | False | | +| SELECT | True | False | | +| SHAPE | True | False | | +| SHUFFLE | True | False | | +| SLICE | True | False | | +| SOFTMAX | True | False | | +| SQUEEZE | True | False | | +| TOPK | True | False | | +| TRIP_LIMIT | True | False | | +| UNARY | True | False | | +| UNSQUEEZE | True | False | | +| ITERATOR | True | False | | +| CONDITIONAL_INPUT | True | False | | +| CONDITIONAL_OUTPUT | True | False | | +| ATTENTION_INPUT | True | False | | +| ATTENTION_OUTPUT | True | False | | +| ROTARY_EMBEDDING | True | False | | +| KVCACHE_UPDATE | True | False | | +| MOE | True | False | | +| DIST_COLLECTIVE | True | False | | diff --git a/packages/isaac_deploy_trt/tests/test_catalog.py b/packages/isaac_deploy_trt/tests/test_catalog.py new file mode 100644 index 00000000..a47b8082 --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_catalog.py @@ -0,0 +1,89 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +from __future__ import annotations + +import json +import tempfile +import unittest +from pathlib import Path + +from isaac_deploy_trt.catalog import build_catalog +from isaac_deploy_trt.headers import parse_tensorrt_headers + +SAMPLE_OPERATORS_MD = """ +# Supported ONNX Operators + +TensorRT 11.2 supports operators in the inclusive range of opset 9 to opset 24. + +## Operator Support Matrix + +| Operator | Supported | Supported Types | Restrictions | +|---------------------------|------------|-----------------|------------------------------------------------------------------------------------------------------------------------| +| Abs | Y | FP32, FP16, BF16, INT32, INT64 | +| AffineGrid | N | +""" + +SAMPLE_HEADERS = """ +enum class DataType : int32_t +{ + kFLOAT = 0, + kHALF = 1, + kINT32 = 3, +}; +enum class LayerType : int32_t +{ + kCONVOLUTION = 0, +}; +enum class NetworkDefinitionCreationFlag : int32_t +{ + kSTRONGLY_TYPED TRT_DEPRECATED_ENUM = 0, +}; +""" + + +class TestCatalogHeaders(unittest.TestCase): + def test_parse_headers(self): + catalog = parse_tensorrt_headers([SAMPLE_HEADERS], sources=["fixture.h"]) + self.assertEqual(catalog.data_types, ["kFLOAT", "kHALF", "kINT32"]) + self.assertEqual(catalog.layer_type_names, ["CONVOLUTION"]) + self.assertTrue(catalog.strongly_typed) + + def test_join_operators_md_with_headers(self): + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + include = Path(tmp) / "include" + include.mkdir() + (include / "NvInfer.h").write_text(SAMPLE_HEADERS, encoding="utf-8") + catalog = build_catalog( + operators_md=str(md_path), + include_dir=str(include), + ) + self.assertEqual( + catalog["onnx_operators"]["Abs"]["nvinfer_datatypes"], + ["kFLOAT", "kHALF", "kINT32"], + ) + self.assertNotIn("kBF16", catalog["onnx_operators"]["Abs"]["nvinfer_datatypes"]) + self.assertTrue(catalog["nvinfer"]["strongly_typed"]) + json.dumps(catalog) + self.assertEqual(catalog["supported_releases"], ["v11.2"]) + + def test_shared_releases(self): + headers = parse_tensorrt_headers([SAMPLE_HEADERS], sources=["fixture.h"]) + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + catalog = build_catalog( + operators_md=str(md_path), + releases=["v11.1", "11.2"], + headers_by_release={"v11.1": headers, "v11.2": headers}, + ) + self.assertEqual(catalog["supported_releases"], ["v11.1", "v11.2"]) + self.assertNotIn("databases", catalog) + + +if __name__ == "__main__": + unittest.main() diff --git a/packages/isaac_deploy_trt/tests/test_generate_catalogs.py b/packages/isaac_deploy_trt/tests/test_generate_catalogs.py new file mode 100644 index 00000000..aab2c532 --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_generate_catalogs.py @@ -0,0 +1,271 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for CUDA 13.2 TensorRT layer catalog generation.""" + +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from isaac_deploy_trt.headers import parse_tensorrt_headers +from isaac_deploy_trt.platform_catalog import ( + DEFAULT_PLATFORMS, + PLATFORMS, + generate, + parse_operators_md, + resolve_platform_name, +) + + +SAMPLE_OPERATORS_MD = """ +# Supported ONNX Operators + +TensorRT 11.2 supports operators in the inclusive range of opset 9 to opset 24. + +## Operator Support Matrix + +| Operator | Supported | Supported Types | Restrictions | +|---------------------------|------------|-----------------|------------------------------------------------------------------------------------------------------------------------| +| Abs | Y | FP32, FP16, BF16, INT32, INT64 | +| Attention | Y | FP32, FP16, BF16, INT8, FP8 | Q, K, V must be 4D | +| AffineGrid | N | +| Conv | Y | FP32, FP16, BF16 | +| DequantizeLinear | Y | INT8, FP8, FP4, INT4 | x_zero_point must be zero | +| DynamicQuantizeLinear | N | Not supported. TensorRT IDynamicQuantize can be composed from ONNX local functions. +| Relu | Y | FP32, FP16, BF16 | +| Xor | Y | BOOL +""" + + +class TestGenerateTensorrtSupportedLayers(unittest.TestCase): + def test_parse_operators_md(self): + doc = parse_operators_md(SAMPLE_OPERATORS_MD, source="sample") + self.assertEqual(doc.tensorrt_version, "11.2") + self.assertEqual(doc.opset_min, 9) + self.assertEqual(doc.opset_max, 24) + by_name = {op.name: op for op in doc.ops} + self.assertTrue(by_name["Abs"].supported) + self.assertIn("BF16", by_name["Abs"].types) + self.assertFalse(by_name["AffineGrid"].supported) + self.assertTrue(by_name["Xor"].supported) + self.assertEqual(by_name["Xor"].types, ["BOOL"]) + self.assertIn("Not supported", by_name["DynamicQuantizeLinear"].restrictions) + + def test_orin_drops_blackwell_precisions_and_keeps_dla(self): + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + result = generate( + platforms=["orin", "thor", "x86", "dgx"], + operators_md=str(md_path), + output_dir=Path(tmp) / "out", + ) + orin = next(c for c in result["catalogs"] if c["platform"] == "orin") + thor = next(c for c in result["catalogs"] if c["platform"] == "thor") + x86 = next(c for c in result["catalogs"] if c["platform"] == "x86") + abs_types = orin["onnx_operators"]["Abs"]["types"] + self.assertNotIn("BF16", abs_types) + self.assertIn("FP16", abs_types) + self.assertIn("INT8", orin["onnx_operators"]["Attention"]["types"]) + self.assertNotIn("FP8", orin["onnx_operators"]["Attention"]["types"]) + self.assertEqual( + orin["onnx_operators"]["DequantizeLinear"]["types"], ["INT8"] + ) + self.assertTrue(orin["dla"]) + self.assertTrue(orin["tensorrt_layers"]["CONVOLUTION"]["dla"]) + self.assertFalse(orin["tensorrt_layers"]["MATRIX_MULTIPLY"]["dla"]) + self.assertFalse(orin["tensorrt_layers"]["ATTENTION"]["gpu"]) + + self.assertIn("FP8", thor["onnx_operators"]["Attention"]["types"]) + self.assertIn("BF16", thor["onnx_operators"]["Abs"]["types"]) + self.assertFalse(thor["dla"]) + self.assertTrue(x86["tensorrt_11"]) + self.assertTrue(x86["tensorrt_layers"]["ATTENTION"]["gpu"]) + self.assertEqual(x86["supported_releases"], ["v11.2"]) + self.assertEqual( + x86["onnx_operators"]["Abs"]["nvinfer_datatypes"], + ["kFLOAT", "kHALF", "kBF16", "kINT32", "kINT64"], + ) + self.assertIn("kFLOAT", orin["onnx_operators"]["Abs"]["nvinfer_datatypes"]) + self.assertNotIn("kBF16", orin["onnx_operators"]["Abs"]["nvinfer_datatypes"]) + + def test_writes_json_and_markdown(self): + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + out = Path(tmp) / "out" + generate( + platforms=["orin"], + operators_md=str(md_path), + output_dir=out, + ) + json_path = out / "tensorrt_layers_cuda132_orin.json" + md_out = out / "tensorrt_layers_cuda132_orin.md" + self.assertTrue(json_path.is_file()) + self.assertTrue(md_out.is_file()) + text = md_out.read_text(encoding="utf-8") + self.assertIn("Jetson Orin", text) + self.assertIn("| Conv |", text) + + def test_platform_keys(self): + self.assertEqual( + set(PLATFORMS), + { + "x86", + "orin", + "thor", + "dgx", + "noble", + "noble-fastos", + "noble-jetpack", + }, + ) + self.assertEqual(DEFAULT_PLATFORMS, ("noble", "noble-fastos", "noble-jetpack")) + self.assertEqual(resolve_platform_name("amd64"), "noble") + self.assertEqual(resolve_platform_name("spark"), "noble-fastos") + self.assertEqual(resolve_platform_name("jetson"), "noble-jetpack") + self.assertEqual(PLATFORMS["noble"].isaac_debian_dist, "noble") + self.assertEqual(PLATFORMS["noble-fastos"].isaac_debian_dist, "noble-fastos") + self.assertEqual(PLATFORMS["noble-jetpack"].isaac_debian_dist, "noble-jetpack") + self.assertFalse(PLATFORMS["noble-fastos"].tensorrt_11) + self.assertFalse(PLATFORMS["noble-jetpack"].tensorrt_11) + self.assertTrue(PLATFORMS["noble-jetpack"].dla) + + def test_isaac_debian_platforms_write_hyphenated_filenames(self): + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + out = Path(tmp) / "out" + result = generate( + platforms=["jetson", "spark", "amd64"], + operators_md=str(md_path), + output_dir=out, + ) + names = {c["platform"] for c in result["catalogs"]} + self.assertEqual(names, {"noble", "noble-fastos", "noble-jetpack"}) + self.assertTrue((out / "tensorrt_layers_cuda132_noble.json").is_file()) + self.assertTrue( + (out / "tensorrt_layers_cuda132_noble-fastos.json").is_file() + ) + self.assertTrue( + (out / "tensorrt_layers_cuda132_noble-jetpack.json").is_file() + ) + jetpack = next( + c for c in result["catalogs"] if c["platform"] == "noble-jetpack" + ) + self.assertEqual(jetpack["isaac_debian_dist"], "noble-jetpack") + self.assertFalse(jetpack["tensorrt_11"]) + self.assertFalse(jetpack["tensorrt_layers"]["ATTENTION"]["gpu"]) + + def test_headers_join_nvinfer_types_and_layer_enum(self): + sample_headers = """ +enum class DataType : int32_t +{ + kFLOAT = 0, + kHALF = 1, + kINT8 = 2, + kINT32 = 3, + kBOOL = 4, + kUINT8 = 5, + kINT64 = 8, +}; +enum class LayerType : int32_t +{ + kCONVOLUTION = 0, + kMOE = 55, +}; +enum class NetworkDefinitionCreationFlag : int32_t +{ + kSTRONGLY_TYPED TRT_DEPRECATED_ENUM = 0, +}; +""" + headers = parse_tensorrt_headers([sample_headers], sources=["fixture.h"]) + self.assertIn("kFLOAT", headers.data_types) + self.assertNotIn("kBF16", headers.data_types) + self.assertTrue(headers.strongly_typed) + self.assertIn("MOE", headers.layer_type_names) + + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + include = Path(tmp) / "include" + include.mkdir() + (include / "NvInfer.h").write_text(sample_headers, encoding="utf-8") + result = generate( + platforms=["x86", "orin"], + operators_md=str(md_path), + include_dir=str(include), + ) + x86 = next(c for c in result["catalogs"] if c["platform"] == "x86") + self.assertEqual( + x86["onnx_operators"]["Abs"]["nvinfer_datatypes"], + ["kFLOAT", "kHALF", "kINT32", "kINT64"], + ) + self.assertNotIn("kBF16", x86["onnx_operators"]["Abs"]["nvinfer_datatypes"]) + self.assertTrue(x86["nvinfer"]["strongly_typed"]) + self.assertIn("MOE", x86["tensorrt_layers"]) + self.assertTrue(x86["tensorrt_layers"]["MOE"]["gpu"]) + orin = next(c for c in result["catalogs"] if c["platform"] == "orin") + self.assertFalse(orin["tensorrt_layers"]["MOE"]["gpu"]) + + def test_identical_release_headers_share_one_database(self): + headers = parse_tensorrt_headers( + [ + """ +enum class DataType : int32_t { kFLOAT = 0, kHALF = 1, }; +enum class LayerType : int32_t { kCONVOLUTION = 0, }; +""" + ], + sources=["same.h"], + ) + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + result = generate( + platforms=["x86"], + operators_md=str(md_path), + releases=["v11.1", "v11.2"], + headers_by_release={"v11.1": headers, "v11.2": headers}, + ) + self.assertEqual(len(result["databases"]), 1) + self.assertEqual( + result["catalogs"][0]["supported_releases"], ["v11.1", "v11.2"] + ) + self.assertEqual(result["databases"][0]["id"], "v11.2") + + def test_different_release_headers_make_two_databases(self): + h10 = parse_tensorrt_headers( + ["enum class DataType : int32_t { kFLOAT = 0, };"], + sources=["t10.h"], + ) + h11 = parse_tensorrt_headers( + ["enum class DataType : int32_t { kFLOAT = 0, kBF16 = 7, };"], + sources=["t11.h"], + ) + with tempfile.TemporaryDirectory() as tmp: + md_path = Path(tmp) / "operators.md" + md_path.write_text(SAMPLE_OPERATORS_MD, encoding="utf-8") + out = Path(tmp) / "out" + result = generate( + platforms=["x86"], + operators_md=str(md_path), + output_dir=out, + releases=["v10.16", "v11.2"], + headers_by_release={"v10.16": h10, "v11.2": h11}, + ) + self.assertEqual(len(result["databases"]), 2) + by_id = {db["id"]: db for db in result["databases"]} + self.assertEqual(by_id["v10.16"]["supported_releases"], ["v10.16"]) + self.assertEqual(by_id["v11.2"]["supported_releases"], ["v11.2"]) + self.assertTrue((out / "v10.16" / "tensorrt_layers_cuda132_x86.json").is_file()) + self.assertTrue((out / "v11.2" / "tensorrt_layers_cuda132_x86.json").is_file()) + index = (out / "index.json").read_text(encoding="utf-8") + self.assertIn("release_to_database", index) + + +if __name__ == "__main__": + unittest.main() diff --git a/packages/isaac_deploy_trt/tests/test_pipeline_merge.py b/packages/isaac_deploy_trt/tests/test_pipeline_merge.py new file mode 100644 index 00000000..483f8953 --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_pipeline_merge.py @@ -0,0 +1,271 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for LEAPP ONNX pipeline merge (TensorRTNode, no Triton).""" + +from __future__ import annotations + +import os +import tempfile +import unittest + +import numpy as np +import onnx +from onnx import TensorProto, helper +import yaml + +from isaac_deploy_trt.cli import main +from isaac_deploy_trt.pipeline_merge import ( + merge_leapp_onnx_pipeline, + save_merged_pipeline, +) + + +def _abs_model() -> onnx.ModelProto: + graph = helper.make_graph( + nodes=[helper.make_node("Abs", ["x"], ["h"], name="abs0")], + name="abs", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("h", TensorProto.FLOAT, [2])], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +def _relu_model() -> onnx.ModelProto: + graph = helper.make_graph( + nodes=[helper.make_node("Relu", ["h"], ["y"], name="relu0")], + name="relu", + inputs=[helper.make_tensor_value_info("h", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2])], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +def _identity_model(inp: str, out: str) -> onnx.ModelProto: + graph = helper.make_graph( + nodes=[helper.make_node("Identity", [inp], [out], name=f"id_{out}")], + name="id", + inputs=[helper.make_tensor_value_info(inp, TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info(out, TensorProto.FLOAT, [2])], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +def _write_chain_export(tmp: str) -> str: + onnx.save(_abs_model(), os.path.join(tmp, "pre.onnx")) + onnx.save(_relu_model(), os.path.join(tmp, "post.onnx")) + spec = { + "models": { + "pre": { + "inputs": [{"name": "x", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "pre.onnx", "backend": "onnx"}, + }, + "post": { + "inputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "y", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "post.onnx", "backend": "onnx"}, + }, + }, + "pipeline": { + "data_flow": {"pre/h": ["post/h"]}, + "feedback_flow": {}, + "inputs": {"pre": ["x"]}, + "outputs": {"post": ["y"]}, + }, + } + path = os.path.join(tmp, "exported.yaml") + with open(path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + return path + + +class TestOnnxPipelineMerge(unittest.TestCase): + def test_merge_abs_relu_chain(self): + with tempfile.TemporaryDirectory() as tmp: + yaml_path = _write_chain_export(tmp) + result = merge_leapp_onnx_pipeline(yaml_path) + self.assertEqual(result.input_tensor_names, ["x"]) + self.assertEqual(result.output_tensor_names, ["y"]) + ops = [node.op_type for node in result.model.graph.node] + self.assertEqual(ops, ["Abs", "Relu"]) + onnx.checker.check_model(result.model) + + try: + import onnxruntime as ort + except ImportError: + return + session = ort.InferenceSession( + result.model.SerializeToString(), + providers=["CPUExecutionProvider"], + ) + feed = np.array([-1.0, 2.0], dtype=np.float32) + out = session.run(["y"], {"x": feed})[0] + np.testing.assert_allclose(out, np.array([1.0, 2.0], dtype=np.float32)) + + def test_fan_out(self): + with tempfile.TemporaryDirectory() as tmp: + onnx.save(_abs_model(), os.path.join(tmp, "pre.onnx")) + onnx.save(_relu_model(), os.path.join(tmp, "a.onnx")) + onnx.save(_identity_model("h", "z"), os.path.join(tmp, "b.onnx")) + spec = { + "models": { + "pre": { + "inputs": [{"name": "x", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "pre.onnx", "backend": "onnx"}, + }, + "a": { + "inputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "y", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "a.onnx", "backend": "onnx"}, + }, + "b": { + "inputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "z", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "b.onnx", "backend": "onnx"}, + }, + }, + "pipeline": { + "data_flow": {"pre/h": ["a/h", "b/h"]}, + "feedback_flow": {}, + "inputs": {"pre": ["x"]}, + "outputs": {"a": ["y"], "b": ["z"]}, + }, + } + yaml_path = os.path.join(tmp, "exported.yaml") + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + result = merge_leapp_onnx_pipeline(yaml_path) + self.assertEqual(result.input_tensor_names, ["x"]) + self.assertEqual(result.output_tensor_names, ["y", "z"]) + onnx.checker.check_model(result.model) + + def test_input_output_name_collision(self): + with tempfile.TemporaryDirectory() as tmp: + onnx.save(_identity_model("left_arm", "h"), os.path.join(tmp, "pre.onnx")) + onnx.save(_identity_model("h", "left_arm"), os.path.join(tmp, "post.onnx")) + spec = { + "models": { + "pre": { + "inputs": [{ + "name": "left_arm", + "dtype": "float32", + "shape": [2], + "kind": "state/joint/position", + "element_names": [["joint_a", "joint_b"]], + }], + "outputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "pre.onnx", "backend": "onnx"}, + }, + "post": { + "inputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "left_arm", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "post.onnx", "backend": "onnx"}, + }, + }, + "pipeline": { + "data_flow": {"pre/h": ["post/h"]}, + "feedback_flow": {}, + "inputs": {"pre": ["left_arm"]}, + "outputs": {"post": ["left_arm"]}, + }, + } + yaml_path = os.path.join(tmp, "exported.yaml") + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + result = merge_leapp_onnx_pipeline(yaml_path) + self.assertEqual(result.input_tensor_names, ["_in_left_arm"]) + self.assertEqual(result.output_tensor_names, ["left_arm"]) + self.assertEqual(result.input_rename, {"left_arm": "_in_left_arm"}) + merged_input = result.yaml_spec["models"]["pipeline"]["inputs"][0] + self.assertEqual(merged_input["element_names"], [["joint_a", "joint_b"]]) + onnx.checker.check_model(result.model) + + def test_rewrite_during_merge(self): + with tempfile.TemporaryDirectory() as tmp: + resize = helper.make_node( + "Resize", + ["x", "", "", "scales"], + ["h"], + name="resize0", + mode="linear", + antialias=1, + ) + scales = helper.make_tensor("scales", TensorProto.FLOAT, [4], [1, 1, 1, 1]) + graph = helper.make_graph( + nodes=[resize], + name="rz", + inputs=[ + helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 2, 2]) + ], + outputs=[ + helper.make_tensor_value_info("h", TensorProto.FLOAT, [1, 1, 2, 2]) + ], + initializer=[scales], + ) + onnx.save( + helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)]), + os.path.join(tmp, "pre.onnx"), + ) + onnx.save(_relu_model(), os.path.join(tmp, "post.onnx")) + spec = { + "models": { + "pre": { + "inputs": [{"name": "x", "dtype": "float32", "shape": [1, 1, 2, 2]}], + "outputs": [{"name": "h", "dtype": "float32", "shape": [1, 1, 2, 2]}], + "parameters": {"model_path": "pre.onnx", "backend": "onnx"}, + }, + "post": { + "inputs": [{"name": "h", "dtype": "float32", "shape": [2]}], + "outputs": [{"name": "y", "dtype": "float32", "shape": [2]}], + "parameters": {"model_path": "post.onnx", "backend": "onnx"}, + }, + }, + "pipeline": { + "data_flow": {"pre/h": ["post/h"]}, + "feedback_flow": {}, + "inputs": {"pre": ["x"]}, + "outputs": {"post": ["y"]}, + }, + } + yaml_path = os.path.join(tmp, "exported.yaml") + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + result = merge_leapp_onnx_pipeline(yaml_path, rewrite=True) + self.assertEqual(result.rewritten_models, ["pre"]) + resize_nodes = [ + node for node in result.model.graph.node if node.op_type == "Resize" + ] + self.assertEqual(len(resize_nodes), 1) + antialias = next( + (a.i for a in resize_nodes[0].attribute if a.name == "antialias"), 0 + ) + self.assertEqual(int(antialias), 0) + + def test_cli_merge_pipeline(self): + with tempfile.TemporaryDirectory() as tmp: + yaml_path = _write_chain_export(tmp) + out = os.path.join(tmp, "pipeline.onnx") + self.assertEqual( + main(["merge-pipeline", yaml_path, "-o", out]), + 0, + ) + self.assertTrue(os.path.isfile(out)) + sidecar = os.path.join(tmp, "pipeline.yaml") + self.assertTrue(os.path.isfile(sidecar)) + with open(sidecar, encoding="utf-8") as handle: + spec = yaml.safe_load(handle) + self.assertEqual(spec["tensor_rt_node"]["input_tensor_names"], ["x"]) + self.assertEqual(spec["tensor_rt_node"]["output_tensor_names"], ["y"]) + onnx.checker.check_model(out) + save_merged_pipeline( + merge_leapp_onnx_pipeline(yaml_path), + os.path.join(tmp, "again.onnx"), + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/packages/isaac_deploy_trt/tests/test_surgery.py b/packages/isaac_deploy_trt/tests/test_surgery.py new file mode 100644 index 00000000..5dd111d3 --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_surgery.py @@ -0,0 +1,142 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +from __future__ import annotations + +import os +import tempfile +import unittest + +import numpy as np +import onnx +from onnx import TensorProto, helper + +from isaac_deploy_trt import surgery as ogs +from isaac_deploy_trt.prepare import rewrite_onnx_file + + +def _chain_model() -> onnx.ModelProto: + nodes = [ + helper.make_node("Abs", ["x"], ["a"], name="abs0"), + helper.make_node("Relu", ["a"], ["y"], name="relu0"), + ] + graph = helper.make_graph( + nodes=nodes, + name="chain", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2])], + value_info=[helper.make_tensor_value_info("a", TensorProto.FLOAT, [2])], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +class TestSurgery(unittest.TestCase): + @classmethod + def setUpClass(cls): + try: + ogs._gs() + except ImportError: + raise unittest.SkipTest("onnx-graphsurgeon not installed") + + def test_rewrite_uint8_intermediate_casts(self): + nodes = [ + helper.make_node("Cast", ["x"], ["u"], name="to_u8", to=2), + helper.make_node("Relu", ["u"], ["u2"], name="relu_u"), + helper.make_node("Cast", ["u2"], ["y"], name="to_f32", to=1), + ] + graph = helper.make_graph( + nodes=nodes, + name="u8", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2])], + value_info=[ + helper.make_tensor_value_info("u", TensorProto.UINT8, [2]), + helper.make_tensor_value_info("u2", TensorProto.UINT8, [2]), + ], + ) + model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + gs_graph = ogs.load_graph(model) + rewritten = ogs.rewrite_uint8_intermediate_casts(gs_graph) + self.assertEqual(rewritten, ["to_u8"]) + + def test_disable_resize_antialias(self): + resize = helper.make_node( + "Resize", + ["x", "", "", "scales"], + ["y"], + name="resize0", + mode="linear", + antialias=1, + ) + scales = helper.make_tensor("scales", TensorProto.FLOAT, [4], [1, 1, 2, 2]) + graph = helper.make_graph( + nodes=[resize], + name="rz", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 2, 2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 4, 4])], + initializer=[scales], + ) + model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)]) + gs_graph = ogs.load_graph(model) + self.assertEqual(ogs.disable_resize_antialias(gs_graph), ["resize0"]) + + def test_reduce_reshape_rank_for_tensorrt(self): + target = helper.make_tensor( + "shape9", TensorProto.INT64, [9], [1, 2, 3, 8, 2, 16, 11, 2, 16] + ) + final = helper.make_tensor("shape2", TensorProto.INT64, [2], [352, 1536]) + nodes = [ + helper.make_node("Reshape", ["x", "shape9"], ["v"], name="reshape9"), + helper.make_node( + "Transpose", ["v"], ["p"], name="perm9", perm=[0, 3, 6, 4, 7, 2, 1, 5, 8] + ), + helper.make_node("Reshape", ["p", "shape2"], ["y"], name="reshape2"), + ] + graph = helper.make_graph( + nodes=nodes, + name="shuffle", + inputs=[ + helper.make_tensor_value_info("x", TensorProto.FLOAT, [2, 3, 256, 352]) + ], + outputs=[ + helper.make_tensor_value_info("y", TensorProto.FLOAT, [352, 1536]) + ], + initializer=[target, final], + ) + model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)]) + gs_graph = ogs.load_graph(model) + self.assertEqual(ogs.reduce_reshape_rank_for_tensorrt(gs_graph), ["reshape9"]) + + def test_rewrite_onnx_file_preserves_io(self): + resize = helper.make_node( + "Resize", + ["x", "", "", "scales"], + ["y"], + name="resize0", + mode="linear", + antialias=1, + ) + scales = helper.make_tensor("scales", TensorProto.FLOAT, [4], [1, 1, 2, 2]) + graph = helper.make_graph( + nodes=[resize], + name="rz", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 2, 2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 4, 4])], + initializer=[scales], + ) + model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)]) + with tempfile.TemporaryDirectory() as tmp: + src = os.path.join(tmp, "in.onnx") + dst = os.path.join(tmp, "out.onnx") + onnx.save(model, src) + result = rewrite_onnx_file(src, dst) + self.assertTrue(result.rewritten) + out = onnx.load(dst) + self.assertEqual([i.name for i in out.graph.input], ["x"]) + self.assertEqual([o.name for o in out.graph.output], ["y"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/pyproject.toml b/pyproject.toml index 480d57ec..e5ef215f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -82,6 +82,14 @@ warp-cu13 = [ "cupti-python>=13,<14; sys_platform == 'linux'", "onnxruntime-gpu[cuda,cudnn]>=1.27.0; python_version >= '3.11'", ] +graph-surgery = [ + "onnx-graphsurgeon", +] + +[project.scripts] +leapp = "leapp.cli:main" +isaac_deploy_trt = "isaac_deploy_trt.cli:main" +generate-tensorrt-supported-layers = "isaac_deploy_trt.generate_cmd:main" [tool.uv] conflicts = [ @@ -104,9 +112,9 @@ script-files = [ ] [tool.setuptools.packages.find] -# Include internal visualization modules shipped with leapp. -where = [".", "packages/leapp-visualization/src"] -include = ["leapp*", "leapp_visualization*"] +# Include internal visualization and TensorRT rewrite modules shipped with leapp. +where = [".", "packages/leapp-visualization/src", "packages/isaac_deploy_trt/src"] +include = ["leapp*", "leapp_visualization*", "isaac_deploy_trt*"] exclude = ["tests*"] [tool.setuptools.package-data] diff --git a/scripts/make_trt_aligned_leapp_bundle.py b/scripts/make_trt_aligned_leapp_bundle.py new file mode 100644 index 00000000..6155ef0e --- /dev/null +++ b/scripts/make_trt_aligned_leapp_bundle.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Write a LEAPP export dir with TensorRT-legal ONNX under the original names. + +Isaac Deploy / Triton look up ``preprocess_video.onnx``, ``backbone.onnx``, +etc. next to the YAML. This copies that layout and only rewrites graphs that +need GraphSurgeon (UINT8 Cast, Resize antialias, rank-9 Reshape). Checksums +in the YAML are updated. Graph I/O names/shapes/dtypes are unchanged. + +Example:: + + python scripts/make_trt_aligned_leapp_bundle.py \\ + ../gr00t-leapp-export/apple_pnp_onnx \\ + -o ../gr00t-leapp-export/apple_pnp_onnx_trt +""" + +from __future__ import annotations + +import argparse +import sys + +from leapp.backends.tensorrt_leapp_bundle import align_leapp_export_for_tensorrt + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser( + description=( + "Copy a LEAPP export dir to TensorRT-legal ONNX with aligned names " + "and YAML checksums" + ), + ) + parser.add_argument("export_dir", help="Source LEAPP export directory") + parser.add_argument( + "-o", + "--output", + required=True, + help="Destination directory (must not be the source)", + ) + args = parser.parse_args(argv) + result = align_leapp_export_for_tensorrt(args.export_dir, args.output) + print(f"Wrote aligned TensorRT LEAPP bundle to {result.output_dir}") + for model in result.models: + action = "rewrote" if model.rewritten else "copied" + extra = f" ({len(model.rewritten_nodes)} nodes)" if model.rewritten else "" + print(f" {action} {model.filename}{extra}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/unit_tests/test_optimize_graph.py b/tests/unit_tests/test_optimize_graph.py new file mode 100644 index 00000000..d94120eb --- /dev/null +++ b/tests/unit_tests/test_optimize_graph.py @@ -0,0 +1,104 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for ``leapp.optimize_graph``.""" + +from __future__ import annotations + +import os +import tempfile +import unittest + +import onnx +from onnx import TensorProto, helper +import yaml + +from leapp.export_manager import ExportManager +from leapp.leapp import _MANAGER, optimize_graph + + +def _write_resize_onnx(path: str) -> None: + resize = helper.make_node( + "Resize", + ["x", "", "", "scales"], + ["y"], + name="resize0", + mode="linear", + antialias=1, + ) + scales = helper.make_tensor("scales", TensorProto.FLOAT, [4], [1, 1, 2, 2]) + graph = helper.make_graph( + nodes=[resize], + name="rz", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 2, 2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 4, 4])], + initializer=[scales], + ) + onnx.save( + helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)]), + path, + ) + + +class TestOptimizeGraph(unittest.TestCase): + def test_requires_compiled_yaml(self): + with tempfile.TemporaryDirectory() as tmp: + _MANAGER.set_save_path(tmp) + _MANAGER.set_graph_name("missing_graph") + ExportManager.set_interpret_graph(False) + with self.assertRaises(Exception): + optimize_graph(trt_compatible=True) + + def test_no_options_returns_empty(self): + with tempfile.TemporaryDirectory() as tmp: + _MANAGER.set_save_path(tmp) + _MANAGER.set_graph_name("opt_graph") + ExportManager.set_interpret_graph(False) + yaml_path = os.path.join(tmp, "opt_graph.yaml") + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump({"models": {}}, handle) + result = optimize_graph() + self.assertEqual(result, {}) + + def test_trt_compatible_rewrites_onnx_in_graph_dir(self): + try: + import isaac_deploy_trt.surgery # noqa: F401 + except ImportError: + raise unittest.SkipTest("isaac_deploy_trt is not installed") + + with tempfile.TemporaryDirectory() as tmp: + _MANAGER.set_save_path(tmp) + _MANAGER.set_graph_name("opt_graph") + ExportManager.set_interpret_graph(False) + onnx_path = os.path.join(tmp, "preprocess.onnx") + _write_resize_onnx(onnx_path) + spec = { + "models": { + "preprocess": { + "parameters": { + "model_path": "preprocess.onnx", + "backend": "onnx", + "md5sum": "old", + "sha256sum": "old", + } + } + } + } + with open(os.path.join(tmp, "opt_graph.yaml"), "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + + applied = optimize_graph(trt_compatible=True) + self.assertIn("trt_compatible", applied) + self.assertTrue(applied["trt_compatible"].models[0].rewritten) + + model = onnx.load(onnx_path) + antialias = next( + a.i for a in model.graph.node[0].attribute if a.name == "antialias" + ) + self.assertEqual(int(antialias), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/unit_tests/test_tensorrt_leapp_bundle.py b/tests/unit_tests/test_tensorrt_leapp_bundle.py new file mode 100644 index 00000000..f277f68a --- /dev/null +++ b/tests/unit_tests/test_tensorrt_leapp_bundle.py @@ -0,0 +1,249 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for TensorRT-aligned LEAPP export bundles.""" + +from __future__ import annotations + +import os +import tempfile +import unittest + +import onnx +from onnx import TensorProto, helper +import yaml + +try: + from isaac_deploy_trt.surgery import graph_io_signature + from leapp.backends.tensorrt_leapp_bundle import ( + align_leapp_export_for_tensorrt, + rewrite_leapp_export_for_tensorrt, + ) +except ImportError: + graph_io_signature = None # type: ignore[assignment] + align_leapp_export_for_tensorrt = None # type: ignore[assignment] + rewrite_leapp_export_for_tensorrt = None # type: ignore[assignment] + +from leapp.backends.onnx_export_backend import ONNXExportBackend + + +def _write_abs_onnx(path: str) -> None: + graph = helper.make_graph( + nodes=[helper.make_node("Abs", ["x"], ["y"], name="abs0")], + name="abs", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2])], + ) + onnx.save( + helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]), + path, + ) + + +def _write_det_onnx(path: str) -> None: + graph = helper.make_graph( + nodes=[helper.make_node("Det", ["x"], ["y"], name="det0")], + name="det", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2, 2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [])], + ) + onnx.save( + helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]), + path, + ) + + +def _write_resize_onnx(path: str) -> None: + resize = helper.make_node( + "Resize", + ["x", "", "", "scales"], + ["y"], + name="resize0", + mode="linear", + antialias=1, + ) + scales = helper.make_tensor("scales", TensorProto.FLOAT, [4], [1, 1, 2, 2]) + graph = helper.make_graph( + nodes=[resize], + name="rz", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 2, 2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 4, 4])], + initializer=[scales], + ) + onnx.save( + helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)]), + path, + ) + + +class TestTensorrtLeappBundle(unittest.TestCase): + @classmethod + def setUpClass(cls): + if graph_io_signature is None: + raise unittest.SkipTest("isaac_deploy_trt is not installed") + + def test_aligns_filenames_io_and_yaml_checksums(self): + with tempfile.TemporaryDirectory() as tmp: + src = os.path.join(tmp, "src") + dst = os.path.join(tmp, "dst") + os.makedirs(src) + abs_path = os.path.join(src, "backbone.onnx") + video_path = os.path.join(src, "preprocess_video.onnx") + _write_abs_onnx(abs_path) + _write_resize_onnx(video_path) + sidecar = os.path.join(src, "preprocess_video_trt.onnx") + _write_resize_onnx(sidecar) + + spec = { + "models": { + "backbone": { + "parameters": { + "model_path": "backbone.onnx", + "backend": "onnx", + "md5sum": "old", + "sha256sum": "old", + } + }, + "preprocess_video": { + "parameters": { + "model_path": "preprocess_video.onnx", + "backend": "onnx", + "md5sum": "old", + "sha256sum": "old", + } + }, + } + } + yaml_path = os.path.join(src, "exported_leapp.yaml") + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + + result = align_leapp_export_for_tensorrt(src, dst) + by_name = {model.filename: model for model in result.models} + self.assertFalse(by_name["backbone.onnx"].rewritten) + self.assertTrue(by_name["preprocess_video.onnx"].rewritten) + self.assertTrue(os.path.isfile(os.path.join(dst, "preprocess_video.onnx"))) + self.assertFalse(os.path.isfile(os.path.join(dst, "preprocess_video_trt.onnx"))) + + source_io = graph_io_signature(onnx.load(video_path)) + aligned_io = graph_io_signature( + onnx.load(os.path.join(dst, "preprocess_video.onnx")) + ) + self.assertEqual(source_io, aligned_io) + + with open(os.path.join(dst, "exported_leapp.yaml"), encoding="utf-8") as handle: + out_spec = yaml.safe_load(handle) + video_params = out_spec["models"]["preprocess_video"]["parameters"] + self.assertEqual(video_params["model_path"], "preprocess_video.onnx") + self.assertEqual( + video_params["sha256sum"], by_name["preprocess_video.onnx"].sha256sum + ) + self.assertNotEqual(video_params["sha256sum"], "old") + self.assertEqual( + out_spec["models"]["backbone"]["parameters"]["backend"], "onnx" + ) + self.assertTrue( + out_spec["models"]["backbone"]["parameters"]["tensorrt_compatible"] + ) + self.assertTrue( + video_params["tensorrt_compatible"] + ) + + def test_yaml_marks_unsupported_ops_not_tensorrt_compatible(self): + with tempfile.TemporaryDirectory() as tmp: + src = os.path.join(tmp, "src") + dst = os.path.join(tmp, "dst") + os.makedirs(src) + det_path = os.path.join(src, "head.onnx") + _write_det_onnx(det_path) + spec = { + "models": { + "head": { + "parameters": { + "model_path": "head.onnx", + "backend": "onnx", + "md5sum": "old", + "sha256sum": "old", + } + } + } + } + with open(os.path.join(src, "exported_leapp.yaml"), "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + + align_leapp_export_for_tensorrt(src, dst) + with open(os.path.join(dst, "exported_leapp.yaml"), encoding="utf-8") as handle: + out_spec = yaml.safe_load(handle) + self.assertFalse( + out_spec["models"]["head"]["parameters"]["tensorrt_compatible"] + ) + + def test_rewrite_leapp_export_for_tensorrt_inplace(self): + with tempfile.TemporaryDirectory() as tmp: + video_path = os.path.join(tmp, "preprocess_video.onnx") + _write_resize_onnx(video_path) + spec = { + "models": { + "preprocess_video": { + "parameters": { + "model_path": "preprocess_video.onnx", + "backend": "onnx", + "md5sum": "old", + "sha256sum": "old", + } + } + } + } + yaml_path = os.path.join(tmp, "graph.yaml") + with open(yaml_path, "w", encoding="utf-8") as handle: + yaml.safe_dump(spec, handle) + + before = onnx.load(video_path) + antialias = next( + a.i for a in before.graph.node[0].attribute if a.name == "antialias" + ) + self.assertEqual(int(antialias), 1) + + result = rewrite_leapp_export_for_tensorrt(tmp) + self.assertEqual(result.output_dir, os.path.abspath(tmp)) + self.assertTrue(result.models[0].rewritten) + + after = onnx.load(video_path) + antialias = next( + a.i for a in after.graph.node[0].attribute if a.name == "antialias" + ) + self.assertEqual(int(antialias), 0) + with open(yaml_path, encoding="utf-8") as handle: + out_spec = yaml.safe_load(handle) + self.assertNotEqual( + out_spec["models"]["preprocess_video"]["parameters"]["md5sum"], + "old", + ) + + def test_onnx_export_backend_annotates_tensorrt_compatible(self): + with tempfile.TemporaryDirectory() as tmp: + onnx_path = os.path.join(tmp, "abs.onnx") + _write_abs_onnx(onnx_path) + backend = ONNXExportBackend.__new__(ONNXExportBackend) + backend.backend_params = {} + backend._annotate_tensorrt_compatible(onnx_path) + self.assertTrue(backend.tensorrt_compatible) + self.assertTrue(backend.get_backend_metadata()["tensorrt_compatible"]) + + det_path = os.path.join(tmp, "det.onnx") + _write_det_onnx(det_path) + backend.tensorrt_compatible = None + backend._annotate_tensorrt_compatible(det_path) + self.assertFalse(backend.tensorrt_compatible) + + backend.backend_params = {"annotate_tensorrt_compatible": False} + backend.tensorrt_compatible = None + backend._annotate_tensorrt_compatible(onnx_path) + self.assertIsNone(getattr(backend, "tensorrt_compatible", None)) + self.assertNotIn("tensorrt_compatible", backend.get_backend_metadata()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/unit_tests/test_tensorrt_onnx_graph_split.py b/tests/unit_tests/test_tensorrt_onnx_graph_split.py new file mode 100644 index 00000000..a59282e3 --- /dev/null +++ b/tests/unit_tests/test_tensorrt_onnx_graph_split.py @@ -0,0 +1,128 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Unit tests for TensorRT ONNX graph split helpers.""" + +from __future__ import annotations + +import os +import tempfile +import unittest + +import onnx +from onnx import TensorProto, helper + +from leapp.backends.tensorrt_onnx_graph_split import ( + extract_onnx_subgraph, + is_op_tensorrt_supported, + partition_nodes_by_tensorrt_support, + replace_unsupported_nodes_with_identity, + split_onnx_by_tensorrt_support, +) + + +def _make_mixed_model() -> onnx.ModelProto: + """Build Abs -> Compress -> Relu (supported, unsupported, supported).""" + nodes = [ + helper.make_node("Abs", ["x"], ["a"], name="abs0"), + helper.make_node("Compress", ["a", "cond"], ["c"], name="compress0"), + helper.make_node("Relu", ["c"], ["y"], name="relu0"), + ] + graph = helper.make_graph( + nodes=nodes, + name="mixed", + inputs=[ + helper.make_tensor_value_info("x", TensorProto.FLOAT, [2, 3]), + helper.make_tensor_value_info("cond", TensorProto.BOOL, [2]), + ], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, None)], + value_info=[ + helper.make_tensor_value_info("a", TensorProto.FLOAT, [2, 3]), + helper.make_tensor_value_info("c", TensorProto.FLOAT, None), + ], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +class TestTensorRTOnnxGraphSplit(unittest.TestCase): + @classmethod + def setUpClass(cls): + try: + import isaac_deploy_trt.tensorrt_onnx_ops # noqa: F401 + except ImportError: + raise unittest.SkipTest("isaac_deploy_trt is not installed") + + def test_is_op_tensorrt_supported(self): + self.assertTrue(is_op_tensorrt_supported("Abs")) + self.assertFalse(is_op_tensorrt_supported("Compress")) + self.assertFalse(is_op_tensorrt_supported("TotallyFakeOp")) + self.assertTrue( + is_op_tensorrt_supported("TotallyFakeOp", unknown_as_supported=True) + ) + + def test_partition_nodes_by_tensorrt_support(self): + model = _make_mixed_model() + segments = partition_nodes_by_tensorrt_support(model.graph.node) + self.assertEqual(len(segments), 3) + self.assertEqual((segments[0].start, segments[0].end, segments[0].supported), (0, 1, True)) + self.assertEqual((segments[1].start, segments[1].end, segments[1].supported), (1, 2, False)) + self.assertEqual((segments[2].start, segments[2].end, segments[2].supported), (2, 3, True)) + self.assertEqual(segments[1].ops, ("Compress",)) + + def test_extract_onnx_subgraph(self): + model = _make_mixed_model() + mid = extract_onnx_subgraph(model, 1, 2, graph_name="unsupported_mid") + self.assertEqual(len(mid.graph.node), 1) + self.assertEqual(mid.graph.node[0].op_type, "Compress") + self.assertEqual([i.name for i in mid.graph.input], ["a", "cond"]) + self.assertEqual([o.name for o in mid.graph.output], ["c"]) + + first = extract_onnx_subgraph(model, 0, 1) + self.assertEqual([i.name for i in first.graph.input], ["x"]) + self.assertEqual([o.name for o in first.graph.output], ["a"]) + + def test_split_onnx_by_tensorrt_support_writes_files(self): + model = _make_mixed_model() + with tempfile.TemporaryDirectory() as tmp: + onnx_path = os.path.join(tmp, "mixed.onnx") + out_dir = os.path.join(tmp, "split") + onnx.save(model, onnx_path) + + result = split_onnx_by_tensorrt_support(onnx_path, output_dir=out_dir) + self.assertEqual(len(result.segments), 3) + self.assertEqual(len(result.supported_paths), 2) + self.assertEqual(len(result.unsupported_paths), 1) + self.assertTrue(all(os.path.isfile(p) for p in result.supported_paths)) + self.assertTrue(os.path.isfile(result.unsupported_paths[0])) + + unsupported = onnx.load(result.unsupported_paths[0]) + self.assertEqual([n.op_type for n in unsupported.graph.node], ["Compress"]) + + def test_replace_unsupported_nodes_with_identity(self): + # Abs -> SoftmaxCrossEntropyLoss is awkward; use BitShift-like 1:1 via custom + # unsupported catalog entry simulation with Compress replaced only when 1:1. + # Compress is not 1:1, so leave a Relu->Unique->Relu style with Unique unsupported + # but Unique can be multi-output — use AffineGrid? Also multi-in. + # Det is unsupported and is 1-in / 1-out. + nodes = [ + helper.make_node("Abs", ["x"], ["a"], name="abs0"), + helper.make_node("Det", ["a"], ["d"], name="det0"), + helper.make_node("Relu", ["d"], ["y"], name="relu0"), + ] + graph = helper.make_graph( + nodes=nodes, + name="det_mid", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2, 2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [1])], + ) + model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + replaced = replace_unsupported_nodes_with_identity(model) + self.assertEqual([n.op_type for n in replaced.graph.node], ["Abs", "Identity", "Relu"]) + # Original model unchanged. + self.assertEqual(model.graph.node[1].op_type, "Det") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/unit_tests/test_tensorrt_plugin_replace.py b/tests/unit_tests/test_tensorrt_plugin_replace.py new file mode 100644 index 00000000..cc2ddbf6 --- /dev/null +++ b/tests/unit_tests/test_tensorrt_plugin_replace.py @@ -0,0 +1,149 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Unit tests for TensorRT plugin replacement helpers.""" + +from __future__ import annotations + +import os +import tempfile +import unittest + +import onnx +from onnx import TensorProto, helper + +try: + from isaac_deploy_trt import surgery as ogs +except ImportError: + ogs = None # type: ignore[assignment] + +from leapp.backends.tensorrt_plugin_replace import ( + TrtPluginSpec, + replace_layer_with_trt_plugin, + replace_layers_by_op_with_trt_plugin, + replace_onnx_layer_with_trt_plugin, + replace_subgraph_with_trt_plugin, +) + + +def _chain_model() -> onnx.ModelProto: + nodes = [ + helper.make_node("Abs", ["x"], ["a"], name="abs0"), + helper.make_node("Relu", ["a"], ["y"], name="relu0"), + ] + graph = helper.make_graph( + nodes=nodes, + name="chain", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2])], + value_info=[helper.make_tensor_value_info("a", TensorProto.FLOAT, [2])], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +def _dual_relu_model() -> onnx.ModelProto: + nodes = [ + helper.make_node("Relu", ["x"], ["a"], name="relu0"), + helper.make_node("Relu", ["a"], ["y"], name="relu1"), + ] + graph = helper.make_graph( + nodes=nodes, + name="dual_relu", + inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2])], + outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2])], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +class TestTrtPluginReplace(unittest.TestCase): + @classmethod + def setUpClass(cls): + try: + if ogs is None: + raise unittest.SkipTest("isaac_deploy_trt is not installed") + ogs._gs() # type: ignore[union-attr] + except ImportError: + raise unittest.SkipTest("onnx-graphsurgeon not installed") + + def test_plugin_spec_attrs(self): + spec = TrtPluginSpec( + name="BatchedNMS_TRT", + attrs={"numClasses": 80}, + version="1", + namespace="", + ) + attrs = spec.onnx_attrs() + self.assertEqual(attrs["numClasses"], 80) + self.assertEqual(attrs["plugin_version"], "1") + self.assertEqual(attrs["plugin_namespace"], "") + + def test_replace_layer_with_trt_plugin(self): + graph = ogs.load_graph(_chain_model()) + spec = TrtPluginSpec(name="AbsPlugin_TRT", attrs={"axis": 0}, version="1") + replace_layer_with_trt_plugin(graph, "abs0", spec) + node = ogs.get_node(graph, "abs0") + self.assertEqual(node.op, "AbsPlugin_TRT") + self.assertEqual(node.attrs["axis"], 0) + self.assertEqual(node.attrs["plugin_version"], "1") + + def test_replace_layers_by_op(self): + graph = ogs.load_graph(_dual_relu_model()) + replaced = replace_layers_by_op_with_trt_plugin( + graph, "Relu", "ReluPlugin_TRT" + ) + self.assertEqual(len(replaced), 2) + model = ogs.export_model(graph) + self.assertEqual( + [n.op_type for n in model.graph.node], + ["ReluPlugin_TRT", "ReluPlugin_TRT"], + ) + + def test_replace_subgraph_with_trt_plugin(self): + graph = ogs.load_graph(_chain_model()) + replace_subgraph_with_trt_plugin( + graph, + inputs=["x"], + outputs=["y"], + plugin=TrtPluginSpec( + name="FusedAbsRelu_TRT", + node_name="fused0", + attrs={"fused": 1}, + ), + ) + model = ogs.export_model(graph) + self.assertEqual(len(model.graph.node), 1) + self.assertEqual(model.graph.node[0].op_type, "FusedAbsRelu_TRT") + self.assertEqual(model.graph.node[0].name, "fused0") + + def test_replace_onnx_layer_file_api(self): + model = _chain_model() + with tempfile.TemporaryDirectory() as tmp: + src = os.path.join(tmp, "in.onnx") + dst = os.path.join(tmp, "out.onnx") + onnx.save(model, src) + out = replace_onnx_layer_with_trt_plugin( + src, + plugin=TrtPluginSpec(name="ReluPlugin_TRT", version="2"), + layer_name="relu0", + output_path=dst, + ) + self.assertTrue(os.path.isfile(dst)) + relu = next(n for n in out.graph.node if n.name == "relu0") + self.assertEqual(relu.op_type, "ReluPlugin_TRT") + attr_map = {a.name: a for a in relu.attribute} + self.assertIn("plugin_version", attr_map) + + def test_replace_onnx_layer_requires_single_mode(self): + with self.assertRaises(ValueError): + replace_onnx_layer_with_trt_plugin( + _chain_model(), + plugin="X", + layer_name="abs0", + onnx_op="Relu", + ) + + +if __name__ == "__main__": + unittest.main() From a9141081560faf7e1d68de220f4ecb938106c0e4 Mon Sep 17 00:00:00 2001 From: Tao Zhang Date: Wed, 14 Oct 2026 14:41:39 -0400 Subject: [PATCH 2/5] Add TensorRT unsupported ONNX operator handling --- packages/isaac_deploy_trt/README.md | 27 + .../scripts/list_unsupported_onnx_ops.py | 25 + .../src/isaac_deploy_trt/cli.py | 11 +- .../src/isaac_deploy_trt/prepare.py | 19 + .../src/isaac_deploy_trt/surgery.py | 8 +- .../src/isaac_deploy_trt/tensorrt_onnx_ops.py | 127 +++++ .../src/isaac_deploy_trt/unsupported_cmd.py | 77 +++ .../isaac_deploy_trt/unsupported_surgery.py | 533 ++++++++++++++++++ .../tests/test_unsupported_ops.py | 55 ++ .../tests/test_unsupported_surgery.py | 152 +++++ 10 files changed, 1031 insertions(+), 3 deletions(-) create mode 100644 packages/isaac_deploy_trt/scripts/list_unsupported_onnx_ops.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_cmd.py create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py create mode 100644 packages/isaac_deploy_trt/tests/test_unsupported_ops.py create mode 100644 packages/isaac_deploy_trt/tests/test_unsupported_surgery.py diff --git a/packages/isaac_deploy_trt/README.md b/packages/isaac_deploy_trt/README.md index 5172c34c..43cd4391 100644 --- a/packages/isaac_deploy_trt/README.md +++ b/packages/isaac_deploy_trt/README.md @@ -24,6 +24,14 @@ Use ``merge-pipeline`` (below) to inline a LEAPP DAG for one Isaac | Intermediate `Cast` to UINT8 | Cast to INT32 instead | | `Resize` with `antialias != 0` | Set `antialias=0` | | `Reshape` to rank > 8 | Drop extent-1 axes; remap following `Transpose` perms | +| `BitwiseNot`, BOOL `BitwiseAnd` / `Or` / `Xor` | `Sub(-1, x)`, or `Not` / `And` / `Or` / `Xor` | +| `QLinearConv`, `QLinearMatMul` | Float `Conv` / `MatMul`, zero-point folded into `Sub` | +| `ConvInteger`, `MatMulInteger` | Float product, then `Cast` to INT32 | +| `DynamicQuantizeLinear` | `ReduceMin` / `ReduceMax`, `Round`, `Clip` | +| Static `CenterCropPad` | `Slice` and `Pad` | + +`unsupported-ops` marks these with `surgeon`. String, sequence, and random +ops stay unsupported: TensorRT has no equivalent operator. Graphs without those patterns are **copied** (plus `.onnx.data` sidecars). Output must be a different path than the input. @@ -92,6 +100,25 @@ For `nvidia/GR00T-N1.7-ApplePnP-V1` as exported today: YAML (`exported_leapp.yaml`) is **not** copied by `rewrite-dir`. Copy it yourself if you need a full deploy tree. +### List ONNX operators TensorRT does not support + +Prints the static parser table (onnx-tensorrt `operators.md`). No ONNX file +and no Triton / ONNX Runtime install. This is the same table `check` uses +when it marks an op unsupported. + +```bash +isaac_deploy_trt unsupported-ops +isaac_deploy_trt unsupported-ops --json +isaac_deploy_trt unsupported-ops \ + --catalog tensorrt_catalogs/v11.2/tensorrt_layers_cuda132_x86.json +``` + +Standalone script (same flags): + +```bash +python scripts/list_unsupported_onnx_ops.py +``` + ### Catalog-check ONNX (validate) Static check: ops in the graph vs the baked-in TensorRT `operators.md` table. diff --git a/packages/isaac_deploy_trt/scripts/list_unsupported_onnx_ops.py b/packages/isaac_deploy_trt/scripts/list_unsupported_onnx_ops.py new file mode 100644 index 00000000..60c9f919 --- /dev/null +++ b/packages/isaac_deploy_trt/scripts/list_unsupported_onnx_ops.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""List ONNX operators the TensorRT parser catalog marks unsupported. + +Same as ``isaac_deploy_trt unsupported-ops``. No ONNX model is required. +The table is onnx-tensorrt operators.md, not a Triton or ONNX Runtime kernel list. +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +_SRC = Path(__file__).resolve().parents[1] / "src" +if _SRC.is_dir() and str(_SRC) not in sys.path: + sys.path.insert(0, str(_SRC)) + +from isaac_deploy_trt.unsupported_cmd import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py index fdeec356..8a60acef 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py @@ -20,6 +20,7 @@ save_merged_pipeline, ) from isaac_deploy_trt.prepare import rewrite_directory, rewrite_onnx_file +from isaac_deploy_trt.unsupported_cmd import add_unsupported_arguments, run_unsupported from isaac_deploy_trt.validate import validate_onnx_for_tensorrt @@ -145,7 +146,8 @@ def main(argv: list[str] | None = None) -> int: "GraphSurgeon ONNX rewrites for TensorRT: UINT8 intermediate Casts, " "Resize antialias, Reshape rank > 8. Graph I/O names are preserved. " "Merge a LEAPP YAML DAG into one ONNX graph for TensorRTNode. " - "Also join operators.md with NvInfer.h DataType/LayerType catalogs." + "Also join operators.md with NvInfer.h DataType/LayerType catalogs, " + "and list ONNX operators that catalog marks unsupported." ), ) sub = parser.add_subparsers(dest="command", required=True) @@ -203,6 +205,13 @@ def main(argv: list[str] | None = None) -> int: check.add_argument("--strict", action="store_true", help="Exit 1 if any check fails") check.set_defaults(handler=_cmd_check) + unsupported = sub.add_parser( + "unsupported-ops", + help="List ONNX operators the TensorRT parser catalog marks unsupported", + ) + add_unsupported_arguments(unsupported) + unsupported.set_defaults(handler=run_unsupported) + catalog = sub.add_parser( "catalog", help="Join operators.md with TensorRT header enumerations", diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py index 0cbc3ac2..b01c882a 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py @@ -21,6 +21,10 @@ load_graph, save_graph, ) +from isaac_deploy_trt.tensorrt_onnx_ops import ( + BOOL_ONLY_SURGEON_OPS, + SURGEON_UNSUPPORTED_OPS, +) logger = logging.getLogger(__name__) @@ -33,9 +37,24 @@ class RewriteFileResult: output_path: str = "" +def _tensor_elem_type(model: onnx.ModelProto, name: str): + infos = list(model.graph.input) + list(model.graph.value_info) + list(model.graph.output) + for info in infos: + if info.name == name and info.type.HasField("tensor_type"): + return int(info.type.tensor_type.elem_type) + return None + + def needs_tensorrt_rewrite(model: onnx.ModelProto) -> bool: inits = {init.name: init for init in model.graph.initializer} for node in model.graph.node: + if node.op_type in BOOL_ONLY_SURGEON_OPS: + elem = _tensor_elem_type(model, node.input[0]) if node.input else None + if elem == 9: # BOOL + return True + continue + if node.op_type in SURGEON_UNSUPPORTED_OPS: + return True if node.op_type == "Cast": to_attr = next((a.i for a in node.attribute if a.name == "to"), None) if to_attr == 2: diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py index 2ea5bcc6..d07be9f4 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py @@ -592,7 +592,10 @@ def reduce_reshape_rank_for_tensorrt( def apply_tensorrt_rewrites(graph: GraphLike) -> List[str]: """Run all TensorRT GraphSurgeon rewrites. Returns names of edited nodes.""" + from isaac_deploy_trt.unsupported_surgery import rewrite_unsupported_onnx_ops + rewritten: List[str] = [] + rewritten.extend(rewrite_unsupported_onnx_ops(graph)) rewritten.extend(rewrite_uint8_intermediate_casts(graph)) rewritten.extend(disable_resize_antialias(graph)) rewritten.extend(reduce_reshape_rank_for_tensorrt(graph)) @@ -626,8 +629,9 @@ def rewrite_onnx_for_tensorrt( ) -> ModelProto: """Apply GraphSurgeon rewrites that unblock TensorRT parse for typical ONNX graphs. - Currently: UINT8 intermediate Casts → INT32, Resize ``antialias`` → 0, and - Reshape rank > 8 lowered by dropping extent-1 axes. Graph I/O names, dtypes, + Currently: decompositions of selected TensorRT-unsupported ops, UINT8 + intermediate Casts → INT32, Resize ``antialias`` → 0, and Reshape rank > 8 + lowered by dropping extent-1 axes. Graph I/O names, dtypes, and shapes are left unchanged so downstream YAML / Triton bindings stay valid. """ graph = load_graph(model_or_path) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py index 5ddddf23..d8c5515a 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/tensorrt_onnx_ops.py @@ -22,6 +22,7 @@ from __future__ import annotations +import json from typing import Dict, List, Optional, TypedDict @@ -1165,6 +1166,40 @@ def supported_onnx_ops( return {name for name, info in ops.items() if info["supported"]} +# Unsupported ONNX ops that ``rewrite_unsupported_onnx_ops`` can replace with +# TensorRT-legal operators. Bool bitwise ops are rewritten only when the +# inputs are BOOL. The others are decomposed for the dtypes those ops use. +BOOL_ONLY_SURGEON_OPS = frozenset({"BitwiseAnd", "BitwiseOr", "BitwiseXor"}) +SURGEON_UNSUPPORTED_OPS = frozenset( + { + "BitwiseAnd", + "BitwiseNot", + "BitwiseOr", + "BitwiseXor", + "CenterCropPad", + "ConvInteger", + "DynamicQuantizeLinear", + "MatMulInteger", + "QLinearConv", + "QLinearMatMul", + } +) + + +def _unsupported_row(name: str, restrictions: str) -> Dict[str, object]: + if name in BOOL_ONLY_SURGEON_OPS: + surgeon: object = "BOOL" + elif name in SURGEON_UNSUPPORTED_OPS: + surgeon = True + else: + surgeon = False + return { + "name": name, + "restrictions": restrictions, + "surgeon": surgeon, + } + + def unsupported_onnx_ops( tensorrt: Optional[str] = None, *, @@ -1173,3 +1208,95 @@ def unsupported_onnx_ops( """Return ONNX op names marked supported=False in the selected catalog.""" ops = onnx_ops_for_version(tensorrt, cuda=cuda) return {name for name, info in ops.items() if not info["supported"]} + + +def unsupported_onnx_op_report( + tensorrt: Optional[str] = None, + *, + cuda: Optional[str] = None, +) -> Dict[str, object]: + """List ONNX operators the TensorRT parser catalog marks unsupported. + + This is the static onnx-tensorrt ``operators.md`` table. It does not query + Triton or ONNX Runtime, and it does not read a model file. + """ + catalog = onnx_ops_catalog(tensorrt, cuda=cuda) + rows = [ + _unsupported_row(name, info.get("restrictions") or "") + for name, info in sorted(catalog["ops"].items()) + if not info["supported"] + ] + return { + "tensorrt": catalog["tensorrt"], + "cuda": list(catalog["cuda"]), + "opset_min": catalog["opset_min"], + "opset_max": catalog["opset_max"], + "source": catalog["source"], + "ops": rows, + } + + +def unsupported_onnx_op_report_from_catalog(catalog: Dict[str, object]) -> Dict[str, object]: + """Build the same report from a generated ``tensorrt_catalogs`` JSON object.""" + operators = catalog.get("onnx_operators") or {} + names = catalog.get("onnx_unsupported") + if names is None and isinstance(operators, dict): + names = [ + name + for name, info in operators.items() + if isinstance(info, dict) and not info.get("supported", True) + ] + rows = [] + for name in names or []: + info = operators.get(name) if isinstance(operators, dict) else None + restrictions = "" + if isinstance(info, dict): + restrictions = info.get("restrictions") or "" + rows.append(_unsupported_row(name, restrictions)) + rows.sort(key=lambda row: row["name"]) + opset = catalog.get("opset") or {} + return { + "tensorrt": catalog.get("parser_tensorrt_version") or catalog.get("tensorrt"), + "cuda": catalog.get("cuda"), + "platform": catalog.get("platform"), + "opset_min": opset.get("min") if isinstance(opset, dict) else None, + "opset_max": opset.get("max") if isinstance(opset, dict) else None, + "source": catalog.get("source"), + "ops": rows, + } + + +def load_unsupported_onnx_op_report(path: str) -> Dict[str, object]: + """Load a platform catalog JSON and return its unsupported ONNX operators.""" + with open(path, encoding="utf-8") as handle: + catalog = json.load(handle) + report = unsupported_onnx_op_report_from_catalog(catalog) + report["catalog"] = path + return report + + +def format_unsupported_onnx_op_report(report: Dict[str, object]) -> str: + """Render an unsupported-op report as plain text.""" + header = ( + f"TensorRT {report.get('tensorrt')} " + f"ONNX opset {report.get('opset_min')}-{report.get('opset_max')}" + ) + if report.get("platform"): + header += f" ({report['platform']})" + lines = [header] + if report.get("source"): + lines.append(f"source: {report['source']}") + ops = report["ops"] + lines.append(f"{len(ops)} ONNX operators marked unsupported") + lines.append("A trailing 'surgeon' mark has a GraphSurgeon rewrite.") + for row in ops: + restrictions = row.get("restrictions") or "" + parts = [row["name"]] + if restrictions: + parts.append(restrictions) + if row.get("surgeon") is True: + parts.append("surgeon") + elif row.get("surgeon") == "BOOL": + parts.append("surgeon (BOOL inputs)") + lines.append("\t".join(parts)) + return "\n".join(lines) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_cmd.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_cmd.py new file mode 100644 index 00000000..3882db88 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_cmd.py @@ -0,0 +1,77 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""List ONNX operators the TensorRT parser catalog marks unsupported. + +Kept free of ``onnx`` imports so it runs without the ONNX package installed. +""" + +from __future__ import annotations + +import argparse +import json +import os +import sys + +from isaac_deploy_trt.tensorrt_onnx_ops import ( + format_unsupported_onnx_op_report, + load_unsupported_onnx_op_report, + unsupported_onnx_op_report, +) + + +def add_unsupported_arguments(parser: argparse.ArgumentParser) -> None: + parser.add_argument( + "--tensorrt", + default=None, + help="TensorRT version for the baked-in parser table (default: 11.2)", + ) + parser.add_argument( + "--cuda", + default=None, + help="CUDA version used to pick a baked-in catalog when --tensorrt is omitted", + ) + parser.add_argument( + "--catalog", + default=None, + help="Platform catalog JSON (tensorrt_catalogs/...json) instead of the baked-in table", + ) + parser.add_argument( + "--json", + action="store_true", + help="Print the report as JSON", + ) + + +def run_unsupported(args: argparse.Namespace) -> int: + if args.catalog: + path = os.path.abspath(os.path.expanduser(args.catalog)) + if not os.path.isfile(path): + print(f"error: catalog not found: {path}", file=sys.stderr) + return 2 + report = load_unsupported_onnx_op_report(path) + else: + try: + report = unsupported_onnx_op_report(args.tensorrt, cuda=args.cuda) + except KeyError as exc: + print(f"error: {exc}", file=sys.stderr) + return 2 + if args.json: + print(json.dumps(report, indent=2)) + else: + print(format_unsupported_onnx_op_report(report)) + return 0 + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser( + description="List ONNX operators the TensorRT parser catalog marks unsupported", + ) + add_unsupported_arguments(parser) + return run_unsupported(parser.parse_args(argv)) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py new file mode 100644 index 00000000..fe45384e --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py @@ -0,0 +1,533 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Replace TensorRT-unsupported ONNX ops with supported operators. + +Only operators that have a local, TensorRT-legal decomposition are rewritten. +String, sequence, and random ops are left in place. +""" + +from __future__ import annotations + +import logging +from typing import List, Optional, Sequence + +import numpy as np + +from isaac_deploy_trt.surgery import GraphLike, NodeLike, TensorLike, _gs + +logger = logging.getLogger(__name__) + +_FLOAT = 1 +_UINT8 = 2 +_INT8 = 3 +_INT32 = 6 +_INT64 = 7 +_BOOL = 9 + +_NP_TO_ONNX = { + np.dtype(np.float32): _FLOAT, + np.dtype(np.float16): 10, + np.dtype(np.uint8): _UINT8, + np.dtype(np.int8): _INT8, + np.dtype(np.int32): _INT32, + np.dtype(np.int64): _INT64, + np.dtype(np.bool_): _BOOL, +} + +_BOOL_BITWISE = { + "BitwiseAnd": "And", + "BitwiseOr": "Or", + "BitwiseXor": "Xor", + "BitwiseNot": "Not", +} + +_CONV_ATTRS = ("auto_pad", "dilations", "group", "kernel_shape", "pads", "strides") + + +def _np_dtype(dtype): + if dtype is None: + return None + try: + return np.dtype(dtype) + except TypeError: + return None + + +def _onnx_code(dtype) -> Optional[int]: + np_dtype = _np_dtype(dtype) + if np_dtype is None: + return None + return _NP_TO_ONNX.get(np_dtype) + + +def _is_bool(dtype) -> bool: + return _np_dtype(dtype) == np.dtype(np.bool_) + + +def _node_name(node: NodeLike, fallback: str) -> str: + return node.name or fallback + + +def _optional_input(node: NodeLike, index: int) -> Optional[TensorLike]: + if index >= len(node.inputs): + return None + tensor = node.inputs[index] + if tensor is None or not getattr(tensor, "name", ""): + return None + return tensor + + +def _detach(graph: GraphLike, node: NodeLike) -> None: + for tensor in list(node.inputs): + if tensor is None: + continue + consumers = getattr(tensor, "outputs", None) + if consumers is not None and node in consumers: + consumers.remove(node) + for tensor in list(node.outputs): + if tensor is not None: + tensor.inputs.clear() + node.inputs.clear() + node.outputs.clear() + graph.nodes.remove(node) + + +def _const(name: str, value, dtype) -> TensorLike: + gs = _gs() + return gs.Constant(name=name, values=np.array(value, dtype=dtype)) + + +def _var(name: str, dtype) -> TensorLike: + gs = _gs() + return gs.Variable(name=name, dtype=dtype) + + +def _add(graph: GraphLike, op: str, inputs: Sequence[TensorLike], output: TensorLike, *, name: str, attrs=None) -> NodeLike: + gs = _gs() + node = gs.Node( + op=op, + name=name, + attrs=dict(attrs or {}), + inputs=list(inputs), + outputs=[output], + ) + graph.nodes.append(node) + return node + + +def _cast(graph: GraphLike, tensor: TensorLike, onnx_type: int, np_dtype, name: str) -> TensorLike: + if _onnx_code(tensor.dtype) == onnx_type: + return tensor + casted = _var(name, np_dtype) + _add(graph, "Cast", [tensor], casted, name=name, attrs={"to": int(onnx_type)}) + return casted + + +def _constant_values(tensor: TensorLike) -> Optional[List[int]]: + gs = _gs() + if not isinstance(tensor, gs.Constant): + return None + return [int(v) for v in np.asarray(tensor.values).reshape(-1)] + + +def _numel(tensor: TensorLike) -> Optional[int]: + values = _constant_values(tensor) + if values is not None: + return len(values) + shape = getattr(tensor, "shape", None) + if not shape: + return 1 if shape == () or shape == [] else None + count = 1 + for dim in shape: + if dim is None or isinstance(dim, str): + return None + count *= int(dim) + return count + + +def _broadcast_channels(graph: GraphLike, tensor: TensorLike, ref: TensorLike, name: str): + """Reshape a per-output-channel vector so it broadcasts over ``ref``.""" + count = _numel(tensor) + if count is None or count <= 1: + return tensor + ref_shape = getattr(ref, "shape", None) + if not ref_shape or int(ref_shape[0] or 0) not in (0, count): + return None + target = [count] + [1] * (len(ref_shape) - 1) + shape = _const(f"{name}_shape", target, np.int64) + reshaped = _var(f"{name}_bc", np.float32) + _add(graph, "Reshape", [tensor, shape], reshaped, name=f"{name}_reshape") + return reshaped + + +def _dequantize(graph: GraphLike, prefix: str, value: TensorLike, scale: TensorLike, zero_point: Optional[TensorLike], ref: TensorLike) -> Optional[TensorLike]: + casted = _cast(graph, value, _FLOAT, np.float32, f"{prefix}_f") + current = casted + if zero_point is not None: + zp = _cast(graph, zero_point, _FLOAT, np.float32, f"{prefix}_zp") + zp = _broadcast_channels(graph, zp, ref, f"{prefix}_zp") + if zp is None: + return None + current = _var(f"{prefix}_centered", np.float32) + _add(graph, "Sub", [casted, zp], current, name=f"{prefix}_sub") + scale_b = _broadcast_channels(graph, scale, ref, f"{prefix}_scale") + if scale_b is None: + return None + scaled = _var(f"{prefix}_scaled", np.float32) + _add(graph, "Mul", [current, scale_b], scaled, name=f"{prefix}_mul") + return scaled + + +def _broadcast_ok(param: Optional[TensorLike], ref: TensorLike) -> bool: + if param is None: + return True + return _broadcast_channels_shape_ok(param, ref) + + +def _broadcast_channels_shape_ok(tensor: TensorLike, ref: TensorLike) -> bool: + count = _numel(tensor) + if count is None or count <= 1: + return True + ref_shape = getattr(ref, "shape", None) + return bool(ref_shape) and int(ref_shape[0] or 0) in (0, count) + + +def _qrange(dtype) -> Optional[tuple]: + code = _onnx_code(dtype) + if code == _UINT8: + return (0.0, 255.0) + if code == _INT8: + return (-128.0, 127.0) + return None + + +def _requantize(graph: GraphLike, prefix: str, value: TensorLike, scale: TensorLike, zero_point: Optional[TensorLike], output: TensorLike) -> bool: + bounds = _qrange(output.dtype if output.dtype is not None else None) + if bounds is None: + src_code = _onnx_code(output.dtype) + if src_code is None: + logger.warning("Cannot requantize %s: output dtype is unknown", prefix) + return False + divided = _var(f"{prefix}_div", np.float32) + _add(graph, "Div", [value, scale], divided, name=f"{prefix}_div") + rounded = _var(f"{prefix}_round", np.float32) + _add(graph, "Round", [divided], rounded, name=f"{prefix}_round") + shifted = rounded + if zero_point is not None: + zp = _cast(graph, zero_point, _FLOAT, np.float32, f"{prefix}_yzp") + shifted = _var(f"{prefix}_shifted", np.float32) + _add(graph, "Add", [rounded, zp], shifted, name=f"{prefix}_addzp") + clipped = shifted + if bounds is not None: + low = _const(f"{prefix}_qmin", bounds[0], np.float32) + high = _const(f"{prefix}_qmax", bounds[1], np.float32) + clipped = _var(f"{prefix}_clip", np.float32) + _add(graph, "Clip", [shifted, low, high], clipped, name=f"{prefix}_clip") + code = _onnx_code(output.dtype) or _INT8 + _add(graph, "Cast", [clipped], output, name=f"{prefix}_cast", attrs={"to": int(code)}) + return True + + +def _conv_attrs(node: NodeLike) -> dict: + return {key: node.attrs[key] for key in _CONV_ATTRS if key in node.attrs} + + +def rewrite_bitwise_ops(graph: GraphLike) -> List[str]: + """Rewrite BOOL bitwise ops, and integer ``BitwiseNot``, into supported ops. + + ``BitwiseNot`` on integers is ``-1 - x`` (two's complement). Integer + ``BitwiseAnd`` / ``Or`` / ``Xor`` and ``BitShift`` have no TensorRT op. + """ + rewritten: List[str] = [] + for node in list(graph.nodes): + name = _node_name(node, f"{node.op}_{id(node)}") + if node.op in _BOOL_BITWISE and node.inputs and all(_is_bool(t.dtype) for t in node.inputs): + node.op = _BOOL_BITWISE[node.op] + node.attrs.clear() + rewritten.append(name) + continue + if node.op != "BitwiseNot" or len(node.outputs) != 1: + continue + source = node.inputs[0] + result = node.outputs[0] + code = _onnx_code(source.dtype) or _onnx_code(result.dtype) + if code not in (_INT8, _INT32, _INT64, _UINT8): + logger.warning("Leaving %s: BitwiseNot dtype is not an integer TensorRT can subtract", name) + continue + calc = _INT64 if code == _INT64 else _INT32 + calc_np = np.int64 if calc == _INT64 else np.int32 + _detach(graph, node) + widened = _cast(graph, source, calc, calc_np, f"{name}_wide") + neg_one = _const(f"{name}_neg1", -1, calc_np) + if code == calc: + _add(graph, "Sub", [neg_one, widened], result, name=f"{name}_sub") + else: + temporary = _var(f"{name}_wide_out", calc_np) + _add(graph, "Sub", [neg_one, widened], temporary, name=f"{name}_sub") + _add( + graph, + "Cast", + [temporary], + result, + name=f"{name}_narrow", + attrs={"to": int(code)}, + ) + rewritten.append(name) + return rewritten + + +def _rewrite_qlinear(graph: GraphLike, node: NodeLike, *, kind: str) -> bool: + """Fold zero-points into Sub/Mul. TensorRT QuantizeLinear requires zp = 0.""" + name = _node_name(node, kind) + if kind == "QLinearConv": + slots = (0, 1, 2, 3, 4, 5, 6, 7, 8) + else: + slots = (0, 1, 2, 3, 4, 5, 6, 7) + tensors = [_optional_input(node, index) for index in slots] + if kind == "QLinearConv": + x, x_scale, x_zp, w, w_scale, w_zp, y_scale, y_zp, bias = tensors + else: + x, x_scale, x_zp, w, w_scale, w_zp, y_scale, y_zp = tensors + bias = None + if x is None or x_scale is None or w is None or w_scale is None or y_scale is None: + logger.warning("Leaving %s: missing QLinear inputs", name) + return False + output = node.outputs[0] + out_dtype = output.dtype if output.dtype is not None else x.dtype + if _qrange(out_dtype) is None: + logger.warning("Leaving %s: output dtype is not INT8 or UINT8", name) + return False + if not all(_broadcast_ok(param, ref) for param, ref in ((x_scale, x), (x_zp, x), (w_scale, w), (w_zp, w))): + logger.warning("Leaving %s: per-channel scale rank is unknown", name) + return False + _detach(graph, node) + x_f = _dequantize(graph, f"{name}_x", x, x_scale, x_zp, x) + w_f = _dequantize(graph, f"{name}_w", w, w_scale, w_zp, w) + if x_f is None or w_f is None: + return False + conv_inputs = [x_f, w_f] + if bias is not None: + conv_inputs.append(_cast(graph, bias, _FLOAT, np.float32, f"{name}_bias")) + conv_out = _var(f"{name}_conv", np.float32) + op = "Conv" if kind == "QLinearConv" else "MatMul" + attrs = _conv_attrs(node) if kind == "QLinearConv" else {} + _add(graph, op, conv_inputs, conv_out, name=f"{name}_{op.lower()}", attrs=attrs) + output.dtype = out_dtype + return _requantize(graph, name, conv_out, y_scale, y_zp, output) + + +def rewrite_qlinear_ops(graph: GraphLike) -> List[str]: + """Replace ``QLinearConv`` and ``QLinearMatMul`` with float Conv/MatMul.""" + rewritten: List[str] = [] + for node in list(graph.nodes): + if node.op not in ("QLinearConv", "QLinearMatMul"): + continue + name = _node_name(node, node.op) + if _rewrite_qlinear(graph, node, kind=node.op): + rewritten.append(name) + return rewritten + + +def _rewrite_integer_product(graph: GraphLike, node: NodeLike) -> bool: + name = _node_name(node, node.op) + x = _optional_input(node, 0) + w = _optional_input(node, 1) + x_zp = _optional_input(node, 2) + w_zp = _optional_input(node, 3) + if x is None or w is None or not node.outputs: + return False + if not all(_broadcast_ok(param, ref) for param, ref in ((x_zp, x), (w_zp, w))): + logger.warning("Leaving %s: zero-point rank is unknown", _node_name(node, node.op)) + return False + output = node.outputs[0] + attrs = _conv_attrs(node) if node.op == "ConvInteger" else {} + op = "Conv" if node.op == "ConvInteger" else "MatMul" + _detach(graph, node) + one_x = _const(f"{name}_x_scale", 1.0, np.float32) + one_w = _const(f"{name}_w_scale", 1.0, np.float32) + x_f = _dequantize(graph, f"{name}_x", x, one_x, x_zp, x) + w_f = _dequantize(graph, f"{name}_w", w, one_w, w_zp, w) + if x_f is None or w_f is None: + return False + produced = _var(f"{name}_f", np.float32) + _add(graph, op, [x_f, w_f], produced, name=f"{name}_{op.lower()}", attrs=attrs) + _add(graph, "Cast", [produced], output, name=f"{name}_i32", attrs={"to": _INT32}) + output.dtype = np.int32 + return True + + +def rewrite_integer_conv_matmul(graph: GraphLike) -> List[str]: + """Replace ``ConvInteger`` / ``MatMulInteger`` with a float product cast to INT32. + + The product is exact while the accumulator stays inside the FP32 mantissa + (24 bits). Large int8 reductions can round. + """ + rewritten: List[str] = [] + for node in list(graph.nodes): + if node.op not in ("ConvInteger", "MatMulInteger"): + continue + name = _node_name(node, node.op) + if _rewrite_integer_product(graph, node): + rewritten.append(name) + return rewritten + + +def rewrite_dynamic_quantize_linear(graph: GraphLike) -> List[str]: + """Expand ``DynamicQuantizeLinear`` into ReduceMin/Max, Round, and Clip. + + TensorRT's parser rejects the fused op and documents this composition. + The input rank must be known so ReduceMin/Max axes are constant. + """ + rewritten: List[str] = [] + for node in list(graph.nodes): + if node.op != "DynamicQuantizeLinear" or len(node.outputs) < 3: + continue + name = _node_name(node, "DynamicQuantizeLinear") + source = node.inputs[0] + shape = getattr(source, "shape", None) + if shape is None: + logger.warning("Leaving %s: input rank is unknown", name) + continue + y, y_scale, y_zp = node.outputs[:3] + rank = len(shape) + _detach(graph, node) + if rank == 0: + x_min = source + x_max = source + else: + axes = list(range(rank)) + x_min = _var(f"{name}_min0", np.float32) + x_max = _var(f"{name}_max0", np.float32) + _add(graph, "ReduceMin", [source], x_min, name=f"{name}_rmin", attrs={"axes": axes, "keepdims": 0}) + _add(graph, "ReduceMax", [source], x_max, name=f"{name}_rmax", attrs={"axes": axes, "keepdims": 0}) + zero = _const(f"{name}_zero", 0.0, np.float32) + x_min_c = _var(f"{name}_min", np.float32) + x_max_c = _var(f"{name}_max", np.float32) + _add(graph, "Min", [x_min, zero], x_min_c, name=f"{name}_minc") + _add(graph, "Max", [x_max, zero], x_max_c, name=f"{name}_maxc") + span = _var(f"{name}_span", np.float32) + _add(graph, "Sub", [x_max_c, x_min_c], span, name=f"{name}_span") + levels = _const(f"{name}_255", 255.0, np.float32) + raw_scale = _var(f"{name}_raw_scale", np.float32) + _add(graph, "Div", [span, levels], raw_scale, name=f"{name}_raw_scale") + one = _const(f"{name}_one", 1.0, np.float32) + scale_is_zero = _var(f"{name}_scale0", np.bool_) + _add(graph, "Equal", [raw_scale, zero], scale_is_zero, name=f"{name}_eq") + _add(graph, "Where", [scale_is_zero, one, raw_scale], y_scale, name=f"{name}_scale") + y_scale.dtype = np.float32 + neg_min = _var(f"{name}_negmin", np.float32) + _add(graph, "Sub", [zero, x_min_c], neg_min, name=f"{name}_negmin") + zp_div = _var(f"{name}_zpdiv", np.float32) + _add(graph, "Div", [neg_min, y_scale], zp_div, name=f"{name}_zpdiv") + zp_round = _var(f"{name}_zpround", np.float32) + _add(graph, "Round", [zp_div], zp_round, name=f"{name}_zpround") + low = _const(f"{name}_qmin", 0.0, np.float32) + high = _const(f"{name}_qmax", 255.0, np.float32) + zp_clip = _var(f"{name}_zpclip", np.float32) + _add(graph, "Clip", [zp_round, low, high], zp_clip, name=f"{name}_zpclip") + _add(graph, "Cast", [zp_clip], y_zp, name=f"{name}_zp", attrs={"to": _UINT8}) + y_zp.dtype = np.uint8 + q_div = _var(f"{name}_qdiv", np.float32) + _add(graph, "Div", [source, y_scale], q_div, name=f"{name}_qdiv") + q_round = _var(f"{name}_qround", np.float32) + _add(graph, "Round", [q_div], q_round, name=f"{name}_qround") + q_shift = _var(f"{name}_qshift", np.float32) + _add(graph, "Add", [q_round, zp_clip], q_shift, name=f"{name}_qshift") + q_clip = _var(f"{name}_qclip", np.float32) + _add(graph, "Clip", [q_shift, low, high], q_clip, name=f"{name}_qclip") + _add(graph, "Cast", [q_clip], y, name=f"{name}_y", attrs={"to": _UINT8}) + y.dtype = np.uint8 + rewritten.append(name) + return rewritten + + +def rewrite_center_crop_pad(graph: GraphLike) -> List[str]: + """Replace static ``CenterCropPad`` with Slice and Pad.""" + rewritten: List[str] = [] + for node in list(graph.nodes): + if node.op != "CenterCropPad" or len(node.inputs) < 2 or not node.outputs: + continue + name = _node_name(node, "CenterCropPad") + source = node.inputs[0] + target = _constant_values(node.inputs[1]) + in_shape = getattr(source, "shape", None) + if target is None or not in_shape or any(dim is None or isinstance(dim, str) for dim in in_shape): + logger.warning("Leaving %s: input shape or target shape is not constant", name) + continue + rank = len(in_shape) + axes = node.attrs.get("axes") + if axes is None: + axes = list(range(rank - len(target), rank)) + axes = [int(axis) for axis in axes] + if len(axes) != len(target): + logger.warning("Leaving %s: axes and target shape differ in length", name) + continue + output = node.outputs[0] + starts = [0] * rank + ends = [int(dim) for dim in in_shape] + pad_begin = [0] * rank + pad_end = [0] * rank + for axis, size in zip(axes, target): + if axis < 0: + axis += rank + diff = int(in_shape[axis]) - int(size) + if diff > 0: + starts[axis] = diff // 2 + ends[axis] = starts[axis] + int(size) + elif diff < 0: + pad_begin[axis] = (-diff) // 2 + pad_end[axis] = (-diff) - pad_begin[axis] + needs_slice = starts != [0] * rank or ends != [int(dim) for dim in in_shape] + needs_pad = any(pad_begin) or any(pad_end) + _detach(graph, node) + current = source + if needs_slice: + sliced = output if not needs_pad else _var(f"{name}_sliced", source.dtype) + _add( + graph, + "Slice", + [ + current, + _const(f"{name}_starts", starts, np.int64), + _const(f"{name}_ends", ends, np.int64), + _const(f"{name}_axes", list(range(rank)), np.int64), + _const(f"{name}_steps", [1] * rank, np.int64), + ], + sliced, + name=f"{name}_slice", + ) + current = sliced + if needs_pad: + pad_dtype = _np_dtype(source.dtype) or np.dtype(np.float32) + _add( + graph, + "Pad", + [ + current, + _const(f"{name}_pads", pad_begin + pad_end, np.int64), + _const(f"{name}_padvalue", 0, pad_dtype), + ], + output, + name=f"{name}_pad", + attrs={"mode": "constant"}, + ) + elif not needs_slice: + _add(graph, "Identity", [current], output, name=f"{name}_id") + rewritten.append(name) + return rewritten + + +def rewrite_unsupported_onnx_ops(graph: GraphLike) -> List[str]: + """Rewrite TensorRT-unsupported ops that have a supported decomposition.""" + rewritten: List[str] = [] + rewritten.extend(rewrite_bitwise_ops(graph)) + rewritten.extend(rewrite_qlinear_ops(graph)) + rewritten.extend(rewrite_integer_conv_matmul(graph)) + rewritten.extend(rewrite_dynamic_quantize_linear(graph)) + rewritten.extend(rewrite_center_crop_pad(graph)) + if rewritten: + logger.info("Rewrote TensorRT-unsupported ops: %s", rewritten) + return rewritten diff --git a/packages/isaac_deploy_trt/tests/test_unsupported_ops.py b/packages/isaac_deploy_trt/tests/test_unsupported_ops.py new file mode 100644 index 00000000..8c488e5e --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_unsupported_ops.py @@ -0,0 +1,55 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for listing ONNX operators the TensorRT catalog marks unsupported.""" + +from __future__ import annotations + +import json +import unittest +from pathlib import Path + +from isaac_deploy_trt.tensorrt_onnx_ops import ( + format_unsupported_onnx_op_report, + load_unsupported_onnx_op_report, + unsupported_onnx_op_report, +) + +_CATALOG = ( + Path(__file__).resolve().parents[1] + / "tensorrt_catalogs" + / "v11.2" + / "tensorrt_layers_cuda132_x86.json" +) + + +class UnsupportedOpsTests(unittest.TestCase): + def test_report_includes_known_unsupported_op(self): + report = unsupported_onnx_op_report() + names = [row["name"] for row in report["ops"]] + self.assertIn("AffineGrid", names) + self.assertNotIn("Add", names) + dynamic = next(row for row in report["ops"] if row["name"] == "DynamicQuantizeLinear") + self.assertIn("Not supported", dynamic["restrictions"]) + self.assertTrue(dynamic["surgeon"]) + affine = next(row for row in report["ops"] if row["name"] == "AffineGrid") + self.assertFalse(affine["surgeon"]) + + def test_text_report_lists_unsupported_ops(self): + text = format_unsupported_onnx_op_report(unsupported_onnx_op_report()) + self.assertIn("AffineGrid", text) + self.assertIn("marked unsupported", text) + + def test_catalog_json(self): + report = load_unsupported_onnx_op_report(str(_CATALOG)) + names = [row["name"] for row in report["ops"]] + self.assertIn("Unique", names) + self.assertEqual(report["platform"], "x86") + encoded = json.dumps(report) + self.assertIn("DynamicQuantizeLinear", encoded) + + +if __name__ == "__main__": + unittest.main() diff --git a/packages/isaac_deploy_trt/tests/test_unsupported_surgery.py b/packages/isaac_deploy_trt/tests/test_unsupported_surgery.py new file mode 100644 index 00000000..2646600b --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_unsupported_surgery.py @@ -0,0 +1,152 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""GraphSurgeon rewrites for TensorRT-unsupported ONNX operators.""" + +from __future__ import annotations + +import unittest + +import numpy as np +import onnx +from onnx import TensorProto, helper, numpy_helper + +from isaac_deploy_trt import surgery as ogs +from isaac_deploy_trt.prepare import needs_tensorrt_rewrite +from isaac_deploy_trt.unsupported_surgery import rewrite_unsupported_onnx_ops + + +def _model(nodes, inputs, outputs, initializers=None): + graph = helper.make_graph( + nodes=nodes, + name="g", + inputs=inputs, + outputs=outputs, + initializer=initializers or [], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +class UnsupportedSurgeryTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + try: + ogs._gs() + except ImportError: + raise unittest.SkipTest("onnx-graphsurgeon not installed") + + def test_bitwise_not_int32_becomes_sub(self): + model = _model( + [helper.make_node("BitwiseNot", ["x"], ["y"], name="bn")], + [helper.make_tensor_value_info("x", TensorProto.INT32, [2])], + [helper.make_tensor_value_info("y", TensorProto.INT32, [2])], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["bn"]) + ops = [node.op for node in graph.nodes] + self.assertNotIn("BitwiseNot", ops) + sub = next(node for node in graph.nodes if node.op == "Sub") + self.assertEqual(int(sub.inputs[0].values), -1) + self.assertEqual(sub.inputs[1].name, "x") + self.assertEqual(sub.outputs[0].name, "y") + + def test_bool_bitwise_and_becomes_and(self): + model = _model( + [helper.make_node("BitwiseAnd", ["a", "b"], ["y"], name="band")], + [ + helper.make_tensor_value_info("a", TensorProto.BOOL, [2]), + helper.make_tensor_value_info("b", TensorProto.BOOL, [2]), + ], + [helper.make_tensor_value_info("y", TensorProto.BOOL, [2])], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["band"]) + self.assertEqual([node.op for node in graph.nodes], ["And"]) + + def test_integer_bitwise_and_stays(self): + model = _model( + [helper.make_node("BitwiseAnd", ["a", "b"], ["y"], name="band")], + [ + helper.make_tensor_value_info("a", TensorProto.INT32, [2]), + helper.make_tensor_value_info("b", TensorProto.INT32, [2]), + ], + [helper.make_tensor_value_info("y", TensorProto.INT32, [2])], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), []) + self.assertEqual(graph.nodes[0].op, "BitwiseAnd") + + def test_qlinear_conv_becomes_conv(self): + weight = numpy_helper.from_array(np.ones((1, 1, 1, 1), np.int8), "w") + model = _model( + [ + helper.make_node( + "QLinearConv", + ["x", "x_scale", "x_zp", "w", "w_scale", "w_zp", "y_scale", "y_zp"], + ["y"], + name="qlc", + ) + ], + [helper.make_tensor_value_info("x", TensorProto.INT8, [1, 1, 1, 1])], + [helper.make_tensor_value_info("y", TensorProto.INT8, [1, 1, 1, 1])], + [ + numpy_helper.from_array(np.array(0.5, np.float32), "x_scale"), + numpy_helper.from_array(np.array(0, np.int8), "x_zp"), + weight, + numpy_helper.from_array(np.array(0.25, np.float32), "w_scale"), + numpy_helper.from_array(np.array(0, np.int8), "w_zp"), + numpy_helper.from_array(np.array(0.1, np.float32), "y_scale"), + numpy_helper.from_array(np.array(0, np.int8), "y_zp"), + ], + ) + self.assertTrue(needs_tensorrt_rewrite(model)) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["qlc"]) + ops = {node.op for node in graph.nodes} + self.assertIn("Conv", ops) + self.assertNotIn("QLinearConv", ops) + self.assertNotIn("QuantizeLinear", ops) + conv = next(node for node in graph.nodes if node.op == "Conv") + self.assertEqual(conv.outputs[0].name, "qlc_conv") + self.assertEqual(graph.outputs[0].name, "y") + + def test_center_crop_pad_becomes_slice(self): + target = numpy_helper.from_array(np.array([2, 2], np.int64), "shape") + model = _model( + [helper.make_node("CenterCropPad", ["x", "shape"], ["y"], name="crop", axes=[2, 3])], + [helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 4, 4])], + [helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 2, 2])], + [target], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["crop"]) + slice_node = next(node for node in graph.nodes if node.op == "Slice") + starts = [int(v) for v in np.asarray(slice_node.inputs[1].values).reshape(-1)] + ends = [int(v) for v in np.asarray(slice_node.inputs[2].values).reshape(-1)] + self.assertEqual(starts, [0, 0, 1, 1]) + self.assertEqual(ends, [1, 1, 3, 3]) + self.assertEqual(slice_node.outputs[0].name, "y") + + def test_dynamic_quantize_linear_expands(self): + model = _model( + [helper.make_node("DynamicQuantizeLinear", ["x"], ["y", "scale", "zp"], name="dq")], + [helper.make_tensor_value_info("x", TensorProto.FLOAT, [4])], + [ + helper.make_tensor_value_info("y", TensorProto.UINT8, [4]), + helper.make_tensor_value_info("scale", TensorProto.FLOAT, []), + helper.make_tensor_value_info("zp", TensorProto.UINT8, []), + ], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["dq"]) + ops = {node.op for node in graph.nodes} + self.assertNotIn("DynamicQuantizeLinear", ops) + self.assertIn("ReduceMin", ops) + self.assertIn("ReduceMax", ops) + self.assertEqual(graph.outputs[1].name, "scale") + + +if __name__ == "__main__": + unittest.main() From 560d0111ea0d8169528b9469a025483f2889a81f Mon Sep 17 00:00:00 2001 From: Tao Zhang Date: Wed, 21 Oct 2026 14:04:51 -0400 Subject: [PATCH 3/5] Update with options with tensorrt version --- docs/source/guides/debugging.rst | 6 +- packages/isaac_deploy_trt/README.md | 22 ++- .../src/isaac_deploy_trt/cli.py | 97 ++++++++-- .../src/isaac_deploy_trt/prepare.py | 94 +++++++++- .../src/isaac_deploy_trt/surgery.py | 11 +- .../isaac_deploy_trt/unsupported_surgery.py | 45 +++-- .../src/isaac_deploy_trt/validate.py | 170 +++++++++++++++++- .../isaac_deploy_trt/tests/test_surgery.py | 137 +++++++++++++- .../tests/test_unsupported_surgery.py | 152 ---------------- 9 files changed, 529 insertions(+), 205 deletions(-) delete mode 100644 packages/isaac_deploy_trt/tests/test_unsupported_surgery.py diff --git a/docs/source/guides/debugging.rst b/docs/source/guides/debugging.rst index daecf229..a08b0112 100644 --- a/docs/source/guides/debugging.rst +++ b/docs/source/guides/debugging.rst @@ -190,12 +190,16 @@ updates YAML checksums and ``parameters.tensorrt_compatible``. pip install -e ".[graph-surgery]" isaac_deploy_trt check --onnx path/to/model.onnx --strict + isaac_deploy_trt check --onnx path/to/model.onnx --tensorrt 10.16 --platform orin --strict isaac_deploy_trt check --onnx-dir path/to/export_dir --build --strict - isaac_deploy_trt rewrite-dir path/to/export_dir -o path/to/export_dir_trt + isaac_deploy_trt rewrite-dir path/to/export_dir -o path/to/export_dir_trt --tensorrt 10.16 --platform orin isaac_deploy_trt merge-pipeline path/to/export.yaml -o pipeline.onnx --rewrite ``--build`` also runs TensorRT parse/build (requires ``tensorrt``). ``--strict`` exits non-zero if catalog or TensorRT checks fail. +``--tensorrt`` selects a release catalog such as ``10.16``; ``--platform`` +is ``x86``, ``orin``, ``thor``, or ``dgx``. Omitting both keeps the baked-in +TensorRT 11.2 operator table. Set ``backend_params={"annotate_tensorrt_compatible": False}`` to omit the YAML field, or ``{"validate_tensorrt": True, "validate_tensorrt_build": True}`` diff --git a/packages/isaac_deploy_trt/README.md b/packages/isaac_deploy_trt/README.md index 43cd4391..9fdd01c9 100644 --- a/packages/isaac_deploy_trt/README.md +++ b/packages/isaac_deploy_trt/README.md @@ -58,6 +58,9 @@ pip install -e "./packages/isaac_deploy_trt[dev]" ```bash isaac_deploy_trt rewrite IN.onnx -o OUT.onnx + +# TensorRT 10.16, Jetson Orin catalog +isaac_deploy_trt rewrite IN.onnx -o OUT.onnx --tensorrt 10.16 --platform orin ``` Example (the only Apple PnP node that currently needs surgery): @@ -76,9 +79,15 @@ hit the three patterns above are edited. `-o` **must not** be the input directory. ```bash -isaac_deploy_trt rewrite-dir INPUT_DIR -o OUTPUT_DIR +isaac_deploy_trt rewrite-dir INPUT_DIR -o OUTPUT_DIR --tensorrt 10.16 --platform orin ``` +``--tensorrt`` and ``--platform`` select the operator catalog, the same way +they do for ``check``. Unsupported-op decomposition runs only for operators +that catalog marks unsupported. UINT8 Cast, Resize antialias, and Reshape rank +edits still run. ``--platform`` is ``x86`` (default), ``orin``, ``thor``, or +``dgx``. Omitting both flags rewrites every operator that has a decomposition. + GR00T Apple PnP LEAPP pack: ```bash @@ -121,8 +130,12 @@ python scripts/list_unsupported_onnx_ops.py ### Catalog-check ONNX (validate) -Static check: ops in the graph vs the baked-in TensorRT `operators.md` table. -Does **not** rewrite files. Does **not** load `tensorrt_catalogs/*.json`. +Static check: ops in the graph vs a TensorRT operator catalog. +Does **not** rewrite files. With no version flag, the baked-in TensorRT 11.2 +`operators.md` table is used. `--tensorrt` loads that release from +`tensorrt_catalogs/` (`10.16` and `v10.16` both work). `--platform` selects +`x86` (default), `orin`, `thor`, or `dgx`. `--catalog` points at one JSON +file and replaces the version flags. Does **not** catch UINT8 Cast / Resize antialias / rank-9 Reshape. Those only show up with TensorRT parse (`--build`) or `trtexec`. @@ -139,6 +152,9 @@ isaac_deploy_trt check --onnx-dir DIR --strict # also TensorRT parse/build (needs TensorRT installed) isaac_deploy_trt check --onnx-dir DIR --build + +# TensorRT 10.16 catalog, Jetson Orin overlay +isaac_deploy_trt check --onnx PATH.onnx --tensorrt 10.16 --platform orin --strict ``` Examples: diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py index 8a60acef..78274dd0 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py @@ -28,21 +28,55 @@ def _add_logging() -> None: logging.basicConfig(level=logging.INFO, format="[%(levelname)s]: %(message)s") +def _add_target_arguments(parser: argparse.ArgumentParser) -> None: + parser.add_argument( + "--tensorrt", + default=None, + help=( + "TensorRT release for the operator catalog (for example 10.16 or 11.2). " + "Unsupported-op rewrites follow that catalog. " + "Default: rewrite every operator that has a decomposition." + ), + ) + parser.add_argument( + "--platform", + default=None, + help=( + "Platform overlay when selecting a tensorrt_catalogs file: " + "x86, orin, thor, or dgx. Default: x86." + ), + ) + + +def _rewrite_kwargs(args: argparse.Namespace) -> dict: + return {"tensorrt": args.tensorrt, "platform": args.platform} + + def _cmd_rewrite(args: argparse.Namespace) -> int: - result = rewrite_onnx_file(args.onnx, args.output) + try: + result = rewrite_onnx_file(args.onnx, args.output, **_rewrite_kwargs(args)) + except (KeyError, ValueError, FileNotFoundError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 2 action = "rewrote" if result.rewritten else "copied" extra = f" ({len(result.rewritten_nodes)} nodes)" if result.rewritten else "" - print(f"{action} {result.filename}{extra} -> {result.output_path}") + suffix = f" [{result.catalog_path}]" if result.catalog_path else "" + print(f"{action} {result.filename}{extra} -> {result.output_path}{suffix}") return 0 def _cmd_rewrite_dir(args: argparse.Namespace) -> int: - results = rewrite_directory(args.input_dir, args.output) + try: + results = rewrite_directory(args.input_dir, args.output, **_rewrite_kwargs(args)) + except (KeyError, ValueError, FileNotFoundError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 2 print(f"Wrote {len(results)} ONNX file(s) to {os.path.abspath(args.output)}") for item in results: action = "rewrote" if item.rewritten else "copied" extra = f" ({len(item.rewritten_nodes)} nodes)" if item.rewritten else "" - print(f" {action} {item.filename}{extra}") + suffix = f" [{item.catalog_path}]" if item.catalog_path else "" + print(f" {action} {item.filename}{extra}{suffix}") return 0 @@ -75,6 +109,12 @@ def _cmd_merge_pipeline(args: argparse.Namespace) -> int: def _cmd_check(args: argparse.Namespace) -> int: + if args.catalog and (args.tensorrt or args.platform or args.cuda): + print( + "error: --catalog replaces --tensorrt, --platform, and --cuda", + file=sys.stderr, + ) + return 2 paths = [args.onnx] if args.onnx else [] if args.onnx_dir: for name in sorted(os.listdir(args.onnx_dir)): @@ -82,13 +122,22 @@ def _cmd_check(args: argparse.Namespace) -> int: paths.append(os.path.join(args.onnx_dir, name)) failed = 0 for path in paths: - result = validate_onnx_for_tensorrt( - path, - build=args.build, - strict=False, - ) + try: + result = validate_onnx_for_tensorrt( + path, + build=args.build, + strict=False, + tensorrt=args.tensorrt, + cuda=args.cuda, + platform=args.platform, + catalog=args.catalog, + ) + except (KeyError, ValueError, FileNotFoundError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 2 status = "ok" if result.ok else "FAIL" - print(f"{status} {path}") + suffix = f" [{result.catalog_path}]" if result.catalog_path else "" + print(f"{status} {path}{suffix}") if not result.ok: failed += 1 for err in result.errors: @@ -155,6 +204,7 @@ def main(argv: list[str] | None = None) -> int: rewrite = sub.add_parser("rewrite", help="Rewrite one ONNX file") rewrite.add_argument("onnx", help="Input .onnx path") rewrite.add_argument("-o", "--output", required=True, help="Output .onnx path") + _add_target_arguments(rewrite) rewrite.set_defaults(handler=_cmd_rewrite) rewrite_dir = sub.add_parser( @@ -162,6 +212,7 @@ def main(argv: list[str] | None = None) -> int: ) rewrite_dir.add_argument("input_dir", help="Directory of .onnx files") rewrite_dir.add_argument("-o", "--output", required=True, help="Output directory") + _add_target_arguments(rewrite_dir) rewrite_dir.set_defaults(handler=_cmd_rewrite_dir) merge = sub.add_parser( @@ -203,6 +254,32 @@ def main(argv: list[str] | None = None) -> int: src.add_argument("--onnx-dir", help="Directory of .onnx files") check.add_argument("--build", action="store_true", help="Also TensorRT parse/build") check.add_argument("--strict", action="store_true", help="Exit 1 if any check fails") + check.add_argument( + "--tensorrt", + default=None, + help=( + "TensorRT release for the operator catalog (for example 10.16 or 11.2). " + "Default: baked-in 11.2 parser table. Other releases load tensorrt_catalogs." + ), + ) + check.add_argument( + "--platform", + default=None, + help=( + "Platform overlay when selecting a tensorrt_catalogs file: " + "x86, orin, thor, or dgx. Default: x86." + ), + ) + check.add_argument( + "--cuda", + default=None, + help="CUDA version used to pick a catalog (for example 13.2).", + ) + check.add_argument( + "--catalog", + default=None, + help="Platform catalog JSON. Replaces --tensorrt, --platform, and --cuda.", + ) check.set_defaults(handler=_cmd_check) unsupported = sub.add_parser( diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py index b01c882a..a0c03dc8 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py @@ -11,7 +11,7 @@ import os import shutil from dataclasses import dataclass, field -from typing import List +from typing import List, Optional, Sequence, Tuple import onnx @@ -25,6 +25,7 @@ BOOL_ONLY_SURGEON_OPS, SURGEON_UNSUPPORTED_OPS, ) +from isaac_deploy_trt.validate import select_onnx_ops logger = logging.getLogger(__name__) @@ -35,6 +36,7 @@ class RewriteFileResult: rewritten: bool rewritten_nodes: List[str] = field(default_factory=list) output_path: str = "" + catalog_path: str = "" def _tensor_elem_type(model: onnx.ModelProto, name: str): @@ -45,15 +47,55 @@ def _tensor_elem_type(model: onnx.ModelProto, name: str): return None -def needs_tensorrt_rewrite(model: onnx.ModelProto) -> bool: +def surgeon_ops_for_target( + *, + tensorrt: Optional[str] = None, + platform: Optional[str] = None, + cuda: Optional[str] = None, + catalog: Optional[str] = None, +) -> Tuple[Optional[frozenset], Optional[str]]: + """Return surgeon ops the selected catalog marks unsupported, plus its path. + + ``(None, None)`` keeps the full decomposition set used when no TensorRT + release is requested. + """ + if tensorrt is None and platform is None and cuda is None and catalog is None: + return None, None + ops_map, catalog_path = select_onnx_ops( + tensorrt=tensorrt, + cuda=cuda, + platform=platform, + catalog=catalog, + ) + unsupported = { + name + for name, info in ops_map.items() + if isinstance(info, dict) and not info.get("supported") + } + selected = frozenset(unsupported & SURGEON_UNSUPPORTED_OPS) + logger.info( + "TensorRT rewrite catalog %s; surgeon ops: %s", + catalog_path or tensorrt or "baked-in", + ", ".join(sorted(selected)) or "(none)", + ) + return selected, catalog_path + + +def needs_tensorrt_rewrite( + model: onnx.ModelProto, + surgeon_ops: Optional[Sequence[str]] = None, +) -> bool: + allowed = SURGEON_UNSUPPORTED_OPS if surgeon_ops is None else set(surgeon_ops) inits = {init.name: init for init in model.graph.initializer} for node in model.graph.node: if node.op_type in BOOL_ONLY_SURGEON_OPS: + if node.op_type not in allowed: + continue elem = _tensor_elem_type(model, node.input[0]) if node.input else None if elem == 9: # BOOL return True continue - if node.op_type in SURGEON_UNSUPPORTED_OPS: + if node.op_type in allowed: return True if node.op_type == "Cast": to_attr = next((a.i for a in node.attribute if a.name == "to"), None) @@ -82,24 +124,45 @@ def _copy_with_sidecars(src_onnx: str, dst_onnx: str) -> None: shutil.copy2(os.path.join(src_dir, name), os.path.join(dst_dir, name)) -def rewrite_onnx_file(src: str, dst: str) -> RewriteFileResult: - """Rewrite ``src`` in place-of-copy at ``dst``. Preserves graph I/O.""" +def rewrite_onnx_file( + src: str, + dst: str, + *, + tensorrt: Optional[str] = None, + platform: Optional[str] = None, + cuda: Optional[str] = None, + catalog: Optional[str] = None, +) -> RewriteFileResult: + """Rewrite ``src`` in place-of-copy at ``dst``. Preserves graph I/O. + + ``tensorrt`` and ``platform`` select the operator catalog. Unsupported-op + decomposition runs only for operators that catalog marks unsupported. + """ src = os.path.abspath(src) dst = os.path.abspath(dst) os.makedirs(os.path.dirname(dst) or ".", exist_ok=True) filename = os.path.basename(src) + surgeon_ops, catalog_path = surgeon_ops_for_target( + tensorrt=tensorrt, + platform=platform, + cuda=cuda, + catalog=catalog, + ) source_model = onnx.load(src, load_external_data=False) source_io = graph_io_signature(source_model) - if not needs_tensorrt_rewrite(source_model): + if not needs_tensorrt_rewrite(source_model, surgeon_ops=surgeon_ops): _copy_with_sidecars(src, dst) logger.info("Copied %s (no TensorRT GraphSurgeon edits needed)", filename) return RewriteFileResult( - filename=filename, rewritten=False, output_path=dst + filename=filename, + rewritten=False, + output_path=dst, + catalog_path=catalog_path or "", ) graph = load_graph(src) - rewritten_nodes = apply_tensorrt_rewrites(graph) + rewritten_nodes = apply_tensorrt_rewrites(graph, surgeon_ops=surgeon_ops) save_graph(graph, dst) aligned = onnx.load(dst, load_external_data=False) aligned_io = graph_io_signature(aligned) @@ -114,10 +177,19 @@ def rewrite_onnx_file(src: str, dst: str) -> RewriteFileResult: rewritten=True, rewritten_nodes=rewritten_nodes, output_path=dst, + catalog_path=catalog_path or "", ) -def rewrite_directory(input_dir: str, output_dir: str) -> List[RewriteFileResult]: +def rewrite_directory( + input_dir: str, + output_dir: str, + *, + tensorrt: Optional[str] = None, + platform: Optional[str] = None, + cuda: Optional[str] = None, + catalog: Optional[str] = None, +) -> List[RewriteFileResult]: """Rewrite every ``*.onnx`` under ``input_dir`` into ``output_dir``.""" input_dir = os.path.abspath(input_dir) output_dir = os.path.abspath(output_dir) @@ -132,6 +204,10 @@ def rewrite_directory(input_dir: str, output_dir: str) -> List[RewriteFileResult rewrite_onnx_file( os.path.join(input_dir, name), os.path.join(output_dir, name), + tensorrt=tensorrt, + platform=platform, + cuda=cuda, + catalog=catalog, ) ) return results diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py index d07be9f4..652bd0ce 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py @@ -590,12 +590,17 @@ def reduce_reshape_rank_for_tensorrt( return rewritten -def apply_tensorrt_rewrites(graph: GraphLike) -> List[str]: - """Run all TensorRT GraphSurgeon rewrites. Returns names of edited nodes.""" +def apply_tensorrt_rewrites(graph: GraphLike, surgeon_ops: Optional[Sequence[str]] = None) -> List[str]: + """Run all TensorRT GraphSurgeon rewrites. Returns names of edited nodes. + + ``surgeon_ops`` limits unsupported-op decomposition to that catalog subset. + ``None`` rewrites every operator that has a decomposition. UINT8 Cast, + Resize antialias, and Reshape rank edits always run. + """ from isaac_deploy_trt.unsupported_surgery import rewrite_unsupported_onnx_ops rewritten: List[str] = [] - rewritten.extend(rewrite_unsupported_onnx_ops(graph)) + rewritten.extend(rewrite_unsupported_onnx_ops(graph, ops=surgeon_ops)) rewritten.extend(rewrite_uint8_intermediate_casts(graph)) rewritten.extend(disable_resize_antialias(graph)) rewritten.extend(reduce_reshape_rank_for_tensorrt(graph)) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py index fe45384e..8903fc53 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/unsupported_surgery.py @@ -235,7 +235,11 @@ def _conv_attrs(node: NodeLike) -> dict: return {key: node.attrs[key] for key in _CONV_ATTRS if key in node.attrs} -def rewrite_bitwise_ops(graph: GraphLike) -> List[str]: +def _selected(op: str, ops: Optional[Sequence[str]]) -> bool: + return ops is None or op in ops + + +def rewrite_bitwise_ops(graph: GraphLike, ops: Optional[Sequence[str]] = None) -> List[str]: """Rewrite BOOL bitwise ops, and integer ``BitwiseNot``, into supported ops. ``BitwiseNot`` on integers is ``-1 - x`` (two's complement). Integer @@ -243,6 +247,8 @@ def rewrite_bitwise_ops(graph: GraphLike) -> List[str]: """ rewritten: List[str] = [] for node in list(graph.nodes): + if not _selected(node.op, ops): + continue name = _node_name(node, f"{node.op}_{id(node)}") if node.op in _BOOL_BITWISE and node.inputs and all(_is_bool(t.dtype) for t in node.inputs): node.op = _BOOL_BITWISE[node.op] @@ -319,11 +325,11 @@ def _rewrite_qlinear(graph: GraphLike, node: NodeLike, *, kind: str) -> bool: return _requantize(graph, name, conv_out, y_scale, y_zp, output) -def rewrite_qlinear_ops(graph: GraphLike) -> List[str]: +def rewrite_qlinear_ops(graph: GraphLike, ops: Optional[Sequence[str]] = None) -> List[str]: """Replace ``QLinearConv`` and ``QLinearMatMul`` with float Conv/MatMul.""" rewritten: List[str] = [] for node in list(graph.nodes): - if node.op not in ("QLinearConv", "QLinearMatMul"): + if node.op not in ("QLinearConv", "QLinearMatMul") or not _selected(node.op, ops): continue name = _node_name(node, node.op) if _rewrite_qlinear(graph, node, kind=node.op): @@ -359,7 +365,7 @@ def _rewrite_integer_product(graph: GraphLike, node: NodeLike) -> bool: return True -def rewrite_integer_conv_matmul(graph: GraphLike) -> List[str]: +def rewrite_integer_conv_matmul(graph: GraphLike, ops: Optional[Sequence[str]] = None) -> List[str]: """Replace ``ConvInteger`` / ``MatMulInteger`` with a float product cast to INT32. The product is exact while the accumulator stays inside the FP32 mantissa @@ -367,7 +373,7 @@ def rewrite_integer_conv_matmul(graph: GraphLike) -> List[str]: """ rewritten: List[str] = [] for node in list(graph.nodes): - if node.op not in ("ConvInteger", "MatMulInteger"): + if node.op not in ("ConvInteger", "MatMulInteger") or not _selected(node.op, ops): continue name = _node_name(node, node.op) if _rewrite_integer_product(graph, node): @@ -375,7 +381,7 @@ def rewrite_integer_conv_matmul(graph: GraphLike) -> List[str]: return rewritten -def rewrite_dynamic_quantize_linear(graph: GraphLike) -> List[str]: +def rewrite_dynamic_quantize_linear(graph: GraphLike, ops: Optional[Sequence[str]] = None) -> List[str]: """Expand ``DynamicQuantizeLinear`` into ReduceMin/Max, Round, and Clip. TensorRT's parser rejects the fused op and documents this composition. @@ -383,7 +389,7 @@ def rewrite_dynamic_quantize_linear(graph: GraphLike) -> List[str]: """ rewritten: List[str] = [] for node in list(graph.nodes): - if node.op != "DynamicQuantizeLinear" or len(node.outputs) < 3: + if node.op != "DynamicQuantizeLinear" or not _selected(node.op, ops) or len(node.outputs) < 3: continue name = _node_name(node, "DynamicQuantizeLinear") source = node.inputs[0] @@ -444,11 +450,11 @@ def rewrite_dynamic_quantize_linear(graph: GraphLike) -> List[str]: return rewritten -def rewrite_center_crop_pad(graph: GraphLike) -> List[str]: +def rewrite_center_crop_pad(graph: GraphLike, ops: Optional[Sequence[str]] = None) -> List[str]: """Replace static ``CenterCropPad`` with Slice and Pad.""" rewritten: List[str] = [] for node in list(graph.nodes): - if node.op != "CenterCropPad" or len(node.inputs) < 2 or not node.outputs: + if node.op != "CenterCropPad" or not _selected(node.op, ops) or len(node.inputs) < 2 or not node.outputs: continue name = _node_name(node, "CenterCropPad") source = node.inputs[0] @@ -520,14 +526,21 @@ def rewrite_center_crop_pad(graph: GraphLike) -> List[str]: return rewritten -def rewrite_unsupported_onnx_ops(graph: GraphLike) -> List[str]: - """Rewrite TensorRT-unsupported ops that have a supported decomposition.""" +def rewrite_unsupported_onnx_ops( + graph: GraphLike, + ops: Optional[Sequence[str]] = None, +) -> List[str]: + """Rewrite TensorRT-unsupported ops that have a supported decomposition. + + ``ops`` limits the rewrite to those operator names. ``None`` rewrites every + operator that has a decomposition. + """ rewritten: List[str] = [] - rewritten.extend(rewrite_bitwise_ops(graph)) - rewritten.extend(rewrite_qlinear_ops(graph)) - rewritten.extend(rewrite_integer_conv_matmul(graph)) - rewritten.extend(rewrite_dynamic_quantize_linear(graph)) - rewritten.extend(rewrite_center_crop_pad(graph)) + rewritten.extend(rewrite_bitwise_ops(graph, ops)) + rewritten.extend(rewrite_qlinear_ops(graph, ops)) + rewritten.extend(rewrite_integer_conv_matmul(graph, ops)) + rewritten.extend(rewrite_dynamic_quantize_linear(graph, ops)) + rewritten.extend(rewrite_center_crop_pad(graph, ops)) if rewritten: logger.info("Rewrote TensorRT-unsupported ops: %s", rewritten) return rewritten diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py index 57862aca..d8a2b73b 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py @@ -7,16 +7,23 @@ from __future__ import annotations +import json import logging from dataclasses import dataclass, field -from typing import List, Optional, Sequence +from pathlib import Path +from typing import Dict, List, Optional, Sequence import onnx -from isaac_deploy_trt.tensorrt_onnx_ops import onnx_ops_for_version, supported_onnx_ops +from isaac_deploy_trt.tensorrt_onnx_ops import ( + TENSORRT_ONNX_DEFAULT_VERSION, + onnx_ops_for_version, +) logger = logging.getLogger(__name__) +_CATALOG_ROOT = Path(__file__).resolve().parents[2] / "tensorrt_catalogs" + @dataclass class TensorRTOnnxValidationResult: @@ -26,6 +33,7 @@ class TensorRTOnnxValidationResult: unknown_ops: List[str] = field(default_factory=list) parse_ok: Optional[bool] = None build_ok: Optional[bool] = None + catalog_path: Optional[str] = None errors: List[str] = field(default_factory=list) @property @@ -44,28 +52,168 @@ def collect_onnx_op_types(onnx_path: str) -> List[str]: return sorted({node.op_type for node in model.graph.node}) +def _release_tag(version: str) -> str: + cleaned = str(version).strip() + if cleaned[:1] in "vV" and len(cleaned) > 1 and cleaned[1].isdigit(): + return "v" + cleaned[1:] + if cleaned[:1].isdigit(): + return "v" + cleaned + raise ValueError(f"Invalid TensorRT version: {version!r}") + + +def _cuda_matches(entry: str, requested: str) -> bool: + want = requested.strip().lower() + have = entry.strip().lower() + if have.endswith(".x"): + return want == have[:-2] or want.startswith(have[:-1]) + return want == have or want.startswith(have + ".") + + +def resolve_tensorrt_catalog( + tensorrt: str, + *, + platform: str = "x86", + cuda: Optional[str] = None, +) -> Path: + """Return the platform catalog JSON for a TensorRT release. + + ``10.16`` and ``v10.16`` both resolve through ``tensorrt_catalogs/index.json``. + A patch release such as ``10.16.1`` falls back to ``10.16`` when that + database exists. + """ + index_path = _CATALOG_ROOT / "index.json" + if not index_path.is_file(): + raise FileNotFoundError(f"TensorRT catalog index not found: {index_path}") + index = json.loads(index_path.read_text(encoding="utf-8")) + mapping = index.get("release_to_database") or {} + tag = _release_tag(tensorrt) + database = mapping.get(tag) + if database is None: + parts = tag[1:].split(".") + if len(parts) >= 3: + database = mapping.get("v" + ".".join(parts[:2])) + if database is None: + prefix = "v" + ".".join(tag[1:].split(".")[:2]) if "." in tag[1:] else tag + matches = sorted({ + value for key, value in mapping.items() + if key == prefix or key.startswith(prefix + ".") + }) + if len(matches) == 1: + database = matches[0] + elif not matches: + known = ", ".join(sorted(mapping)) + raise KeyError( + f"No ONNX operator catalog for TensorRT {tensorrt!r} " + f"(known releases: {known})" + ) + else: + raise KeyError( + f"TensorRT {tensorrt!r} matches multiple catalogs {matches}. " + "Pass a full release such as 10.16 or 11.2." + ) + + directory = _CATALOG_ROOT / str(database) + files = sorted(directory.glob(f"tensorrt_layers_*_{platform}.json")) + if cuda: + files = [ + path for path in files + if _cuda_matches(_catalog_cuda(path), cuda) + ] + if len(files) == 1: + return files[0] + available = sorted( + path.name for path in directory.glob("tensorrt_layers_*.json") + ) + if not files: + raise KeyError( + f"No {platform} catalog for TensorRT {tensorrt!r} in {directory} " + f"(have {available})" + ) + raise KeyError( + f"Multiple catalogs for TensorRT {tensorrt!r} platform {platform}: " + f"{[path.name for path in files]}. Pass --cuda to select one." + ) + + +def _catalog_cuda(path: Path) -> str: + catalog = json.loads(path.read_text(encoding="utf-8")) + cuda = catalog.get("cuda") + return "" if cuda is None else str(cuda) + + +def _ops_from_catalog_file(path: Path) -> Dict[str, dict]: + catalog = json.loads(path.read_text(encoding="utf-8")) + operators = catalog.get("onnx_operators") or {} + if not isinstance(operators, dict) or not operators: + raise ValueError(f"Catalog has no onnx_operators: {path}") + return operators + + +def select_onnx_ops( + *, + tensorrt: Optional[str] = None, + cuda: Optional[str] = None, + platform: Optional[str] = None, + catalog: Optional[str] = None, +) -> tuple[Dict[str, dict], Optional[str]]: + """Return ``(operator map, catalog path)``. + + The baked-in parser table is used when no version, platform, or catalog + file is requested, and when ``--tensorrt`` names that table (currently + 11.2) without a platform overlay. Any other release is loaded from + ``tensorrt_catalogs``. + """ + if catalog: + path = Path(catalog).expanduser().resolve() + if not path.is_file(): + raise FileNotFoundError(f"Catalog not found: {path}") + return _ops_from_catalog_file(path), str(path) + + if platform is None and catalog is None: + try: + return onnx_ops_for_version(tensorrt, cuda=cuda), None + except KeyError: + if tensorrt is None: + raise + + version = tensorrt or TENSORRT_ONNX_DEFAULT_VERSION + path = resolve_tensorrt_catalog(version, platform=platform or "x86", cuda=cuda) + return _ops_from_catalog_file(path), str(path) + + def check_onnx_ops_against_tensorrt( onnx_path: str, *, known_supported: Optional[Sequence[str]] = None, tensorrt: Optional[str] = None, cuda: Optional[str] = None, + platform: Optional[str] = None, + catalog: Optional[str] = None, ) -> TensorRTOnnxValidationResult: used_ops = collect_onnx_op_types(onnx_path) - ops_map = onnx_ops_for_version(tensorrt, cuda=cuda) + ops_map, catalog_path = select_onnx_ops( + tensorrt=tensorrt, + cuda=cuda, + platform=platform, + catalog=catalog, + ) supported = ( set(known_supported) if known_supported is not None - else supported_onnx_ops(tensorrt, cuda=cuda) + else { + name for name, info in ops_map.items() + if isinstance(info, dict) and info.get("supported") + } ) - catalog = set(ops_map) - unsupported = sorted(op for op in used_ops if op in catalog and op not in supported) - unknown = sorted(op for op in used_ops if op not in catalog) + catalog_names = set(ops_map) + unsupported = sorted(op for op in used_ops if op in catalog_names and op not in supported) + unknown = sorted(op for op in used_ops if op not in catalog_names) result = TensorRTOnnxValidationResult( onnx_path=onnx_path, used_ops=used_ops, unsupported_ops=unsupported, unknown_ops=unknown, + catalog_path=catalog_path, ) if unsupported: result.errors.append( @@ -118,9 +266,15 @@ def validate_onnx_for_tensorrt( strict: bool = False, tensorrt: Optional[str] = None, cuda: Optional[str] = None, + platform: Optional[str] = None, + catalog: Optional[str] = None, ) -> TensorRTOnnxValidationResult: result = check_onnx_ops_against_tensorrt( - onnx_path, tensorrt=tensorrt, cuda=cuda + onnx_path, + tensorrt=tensorrt, + cuda=cuda, + platform=platform, + catalog=catalog, ) if build: built = try_tensorrt_build(onnx_path, build=True) diff --git a/packages/isaac_deploy_trt/tests/test_surgery.py b/packages/isaac_deploy_trt/tests/test_surgery.py index 5dd111d3..d5b598d5 100644 --- a/packages/isaac_deploy_trt/tests/test_surgery.py +++ b/packages/isaac_deploy_trt/tests/test_surgery.py @@ -3,6 +3,8 @@ # SPDX-License-Identifier: Apache-2.0 # +"""GraphSurgeon rewrites that prepare ONNX graphs for TensorRT.""" + from __future__ import annotations import os @@ -11,10 +13,11 @@ import numpy as np import onnx -from onnx import TensorProto, helper +from onnx import TensorProto, helper, numpy_helper from isaac_deploy_trt import surgery as ogs -from isaac_deploy_trt.prepare import rewrite_onnx_file +from isaac_deploy_trt.prepare import needs_tensorrt_rewrite, rewrite_onnx_file +from isaac_deploy_trt.unsupported_surgery import rewrite_unsupported_onnx_ops def _chain_model() -> onnx.ModelProto: @@ -32,7 +35,18 @@ def _chain_model() -> onnx.ModelProto: return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) -class TestSurgery(unittest.TestCase): +def _model(nodes, inputs, outputs, initializers=None): + graph = helper.make_graph( + nodes=nodes, + name="g", + inputs=inputs, + outputs=outputs, + initializer=initializers or [], + ) + return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + + +class _GraphSurgeonTest(unittest.TestCase): @classmethod def setUpClass(cls): try: @@ -40,6 +54,8 @@ def setUpClass(cls): except ImportError: raise unittest.SkipTest("onnx-graphsurgeon not installed") + +class TestSurgery(_GraphSurgeonTest): def test_rewrite_uint8_intermediate_casts(self): nodes = [ helper.make_node("Cast", ["x"], ["u"], name="to_u8", to=2), @@ -138,5 +154,120 @@ def test_rewrite_onnx_file_preserves_io(self): self.assertEqual([o.name for o in out.graph.output], ["y"]) +class UnsupportedSurgeryTests(_GraphSurgeonTest): + def test_bitwise_not_int32_becomes_sub(self): + model = _model( + [helper.make_node("BitwiseNot", ["x"], ["y"], name="bn")], + [helper.make_tensor_value_info("x", TensorProto.INT32, [2])], + [helper.make_tensor_value_info("y", TensorProto.INT32, [2])], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["bn"]) + skipped = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(skipped, ops=frozenset()), []) + self.assertEqual(skipped.nodes[0].op, "BitwiseNot") + ops = [node.op for node in graph.nodes] + self.assertNotIn("BitwiseNot", ops) + sub = next(node for node in graph.nodes if node.op == "Sub") + self.assertEqual(int(sub.inputs[0].values), -1) + self.assertEqual(sub.inputs[1].name, "x") + self.assertEqual(sub.outputs[0].name, "y") + + def test_bool_bitwise_and_becomes_and(self): + model = _model( + [helper.make_node("BitwiseAnd", ["a", "b"], ["y"], name="band")], + [ + helper.make_tensor_value_info("a", TensorProto.BOOL, [2]), + helper.make_tensor_value_info("b", TensorProto.BOOL, [2]), + ], + [helper.make_tensor_value_info("y", TensorProto.BOOL, [2])], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["band"]) + self.assertEqual([node.op for node in graph.nodes], ["And"]) + + def test_integer_bitwise_and_stays(self): + model = _model( + [helper.make_node("BitwiseAnd", ["a", "b"], ["y"], name="band")], + [ + helper.make_tensor_value_info("a", TensorProto.INT32, [2]), + helper.make_tensor_value_info("b", TensorProto.INT32, [2]), + ], + [helper.make_tensor_value_info("y", TensorProto.INT32, [2])], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), []) + self.assertEqual(graph.nodes[0].op, "BitwiseAnd") + + def test_qlinear_conv_becomes_conv(self): + weight = numpy_helper.from_array(np.ones((1, 1, 1, 1), np.int8), "w") + model = _model( + [ + helper.make_node( + "QLinearConv", + ["x", "x_scale", "x_zp", "w", "w_scale", "w_zp", "y_scale", "y_zp"], + ["y"], + name="qlc", + ) + ], + [helper.make_tensor_value_info("x", TensorProto.INT8, [1, 1, 1, 1])], + [helper.make_tensor_value_info("y", TensorProto.INT8, [1, 1, 1, 1])], + [ + numpy_helper.from_array(np.array(0.5, np.float32), "x_scale"), + numpy_helper.from_array(np.array(0, np.int8), "x_zp"), + weight, + numpy_helper.from_array(np.array(0.25, np.float32), "w_scale"), + numpy_helper.from_array(np.array(0, np.int8), "w_zp"), + numpy_helper.from_array(np.array(0.1, np.float32), "y_scale"), + numpy_helper.from_array(np.array(0, np.int8), "y_zp"), + ], + ) + self.assertTrue(needs_tensorrt_rewrite(model)) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["qlc"]) + ops = {node.op for node in graph.nodes} + self.assertIn("Conv", ops) + self.assertNotIn("QLinearConv", ops) + self.assertNotIn("QuantizeLinear", ops) + conv = next(node for node in graph.nodes if node.op == "Conv") + self.assertEqual(conv.outputs[0].name, "qlc_conv") + self.assertEqual(graph.outputs[0].name, "y") + + def test_center_crop_pad_becomes_slice(self): + target = numpy_helper.from_array(np.array([2, 2], np.int64), "shape") + model = _model( + [helper.make_node("CenterCropPad", ["x", "shape"], ["y"], name="crop", axes=[2, 3])], + [helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 4, 4])], + [helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 2, 2])], + [target], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["crop"]) + slice_node = next(node for node in graph.nodes if node.op == "Slice") + starts = [int(v) for v in np.asarray(slice_node.inputs[1].values).reshape(-1)] + ends = [int(v) for v in np.asarray(slice_node.inputs[2].values).reshape(-1)] + self.assertEqual(starts, [0, 0, 1, 1]) + self.assertEqual(ends, [1, 1, 3, 3]) + self.assertEqual(slice_node.outputs[0].name, "y") + + def test_dynamic_quantize_linear_expands(self): + model = _model( + [helper.make_node("DynamicQuantizeLinear", ["x"], ["y", "scale", "zp"], name="dq")], + [helper.make_tensor_value_info("x", TensorProto.FLOAT, [4])], + [ + helper.make_tensor_value_info("y", TensorProto.UINT8, [4]), + helper.make_tensor_value_info("scale", TensorProto.FLOAT, []), + helper.make_tensor_value_info("zp", TensorProto.UINT8, []), + ], + ) + graph = ogs.load_graph(model) + self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["dq"]) + ops = {node.op for node in graph.nodes} + self.assertNotIn("DynamicQuantizeLinear", ops) + self.assertIn("ReduceMin", ops) + self.assertIn("ReduceMax", ops) + self.assertEqual(graph.outputs[1].name, "scale") + + if __name__ == "__main__": unittest.main() diff --git a/packages/isaac_deploy_trt/tests/test_unsupported_surgery.py b/packages/isaac_deploy_trt/tests/test_unsupported_surgery.py deleted file mode 100644 index 2646600b..00000000 --- a/packages/isaac_deploy_trt/tests/test_unsupported_surgery.py +++ /dev/null @@ -1,152 +0,0 @@ -# -# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 -# - -"""GraphSurgeon rewrites for TensorRT-unsupported ONNX operators.""" - -from __future__ import annotations - -import unittest - -import numpy as np -import onnx -from onnx import TensorProto, helper, numpy_helper - -from isaac_deploy_trt import surgery as ogs -from isaac_deploy_trt.prepare import needs_tensorrt_rewrite -from isaac_deploy_trt.unsupported_surgery import rewrite_unsupported_onnx_ops - - -def _model(nodes, inputs, outputs, initializers=None): - graph = helper.make_graph( - nodes=nodes, - name="g", - inputs=inputs, - outputs=outputs, - initializer=initializers or [], - ) - return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) - - -class UnsupportedSurgeryTests(unittest.TestCase): - @classmethod - def setUpClass(cls): - try: - ogs._gs() - except ImportError: - raise unittest.SkipTest("onnx-graphsurgeon not installed") - - def test_bitwise_not_int32_becomes_sub(self): - model = _model( - [helper.make_node("BitwiseNot", ["x"], ["y"], name="bn")], - [helper.make_tensor_value_info("x", TensorProto.INT32, [2])], - [helper.make_tensor_value_info("y", TensorProto.INT32, [2])], - ) - graph = ogs.load_graph(model) - self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["bn"]) - ops = [node.op for node in graph.nodes] - self.assertNotIn("BitwiseNot", ops) - sub = next(node for node in graph.nodes if node.op == "Sub") - self.assertEqual(int(sub.inputs[0].values), -1) - self.assertEqual(sub.inputs[1].name, "x") - self.assertEqual(sub.outputs[0].name, "y") - - def test_bool_bitwise_and_becomes_and(self): - model = _model( - [helper.make_node("BitwiseAnd", ["a", "b"], ["y"], name="band")], - [ - helper.make_tensor_value_info("a", TensorProto.BOOL, [2]), - helper.make_tensor_value_info("b", TensorProto.BOOL, [2]), - ], - [helper.make_tensor_value_info("y", TensorProto.BOOL, [2])], - ) - graph = ogs.load_graph(model) - self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["band"]) - self.assertEqual([node.op for node in graph.nodes], ["And"]) - - def test_integer_bitwise_and_stays(self): - model = _model( - [helper.make_node("BitwiseAnd", ["a", "b"], ["y"], name="band")], - [ - helper.make_tensor_value_info("a", TensorProto.INT32, [2]), - helper.make_tensor_value_info("b", TensorProto.INT32, [2]), - ], - [helper.make_tensor_value_info("y", TensorProto.INT32, [2])], - ) - graph = ogs.load_graph(model) - self.assertEqual(rewrite_unsupported_onnx_ops(graph), []) - self.assertEqual(graph.nodes[0].op, "BitwiseAnd") - - def test_qlinear_conv_becomes_conv(self): - weight = numpy_helper.from_array(np.ones((1, 1, 1, 1), np.int8), "w") - model = _model( - [ - helper.make_node( - "QLinearConv", - ["x", "x_scale", "x_zp", "w", "w_scale", "w_zp", "y_scale", "y_zp"], - ["y"], - name="qlc", - ) - ], - [helper.make_tensor_value_info("x", TensorProto.INT8, [1, 1, 1, 1])], - [helper.make_tensor_value_info("y", TensorProto.INT8, [1, 1, 1, 1])], - [ - numpy_helper.from_array(np.array(0.5, np.float32), "x_scale"), - numpy_helper.from_array(np.array(0, np.int8), "x_zp"), - weight, - numpy_helper.from_array(np.array(0.25, np.float32), "w_scale"), - numpy_helper.from_array(np.array(0, np.int8), "w_zp"), - numpy_helper.from_array(np.array(0.1, np.float32), "y_scale"), - numpy_helper.from_array(np.array(0, np.int8), "y_zp"), - ], - ) - self.assertTrue(needs_tensorrt_rewrite(model)) - graph = ogs.load_graph(model) - self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["qlc"]) - ops = {node.op for node in graph.nodes} - self.assertIn("Conv", ops) - self.assertNotIn("QLinearConv", ops) - self.assertNotIn("QuantizeLinear", ops) - conv = next(node for node in graph.nodes if node.op == "Conv") - self.assertEqual(conv.outputs[0].name, "qlc_conv") - self.assertEqual(graph.outputs[0].name, "y") - - def test_center_crop_pad_becomes_slice(self): - target = numpy_helper.from_array(np.array([2, 2], np.int64), "shape") - model = _model( - [helper.make_node("CenterCropPad", ["x", "shape"], ["y"], name="crop", axes=[2, 3])], - [helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 4, 4])], - [helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 2, 2])], - [target], - ) - graph = ogs.load_graph(model) - self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["crop"]) - slice_node = next(node for node in graph.nodes if node.op == "Slice") - starts = [int(v) for v in np.asarray(slice_node.inputs[1].values).reshape(-1)] - ends = [int(v) for v in np.asarray(slice_node.inputs[2].values).reshape(-1)] - self.assertEqual(starts, [0, 0, 1, 1]) - self.assertEqual(ends, [1, 1, 3, 3]) - self.assertEqual(slice_node.outputs[0].name, "y") - - def test_dynamic_quantize_linear_expands(self): - model = _model( - [helper.make_node("DynamicQuantizeLinear", ["x"], ["y", "scale", "zp"], name="dq")], - [helper.make_tensor_value_info("x", TensorProto.FLOAT, [4])], - [ - helper.make_tensor_value_info("y", TensorProto.UINT8, [4]), - helper.make_tensor_value_info("scale", TensorProto.FLOAT, []), - helper.make_tensor_value_info("zp", TensorProto.UINT8, []), - ], - ) - graph = ogs.load_graph(model) - self.assertEqual(rewrite_unsupported_onnx_ops(graph), ["dq"]) - ops = {node.op for node in graph.nodes} - self.assertNotIn("DynamicQuantizeLinear", ops) - self.assertIn("ReduceMin", ops) - self.assertIn("ReduceMax", ops) - self.assertEqual(graph.outputs[1].name, "scale") - - -if __name__ == "__main__": - unittest.main() From cd4b8893f96809874db8bbe01e5e8ebf3bf7f858 Mon Sep 17 00:00:00 2001 From: Tao Zhang Date: Mon, 26 Oct 2026 16:44:03 -0400 Subject: [PATCH 4/5] Cleanup --- AGENTS.md | 22 ++-- docs/source/api/index.rst | 14 ++- docs/source/generated_configs.rst | 15 +-- docs/source/guides/debugging.rst | 34 ++++-- leapp/backends/tensorrt_leapp_bundle.py | 7 +- leapp/cli.py | 10 +- leapp/leapp.py | 10 +- packages/isaac_deploy_trt/README.md | 67 ++++++++---- packages/isaac_deploy_trt/pyproject.toml | 2 +- .../src/isaac_deploy_trt/cli.py | 100 ++++++++++++------ .../src/isaac_deploy_trt/pipeline_merge.py | 18 ++-- .../src/isaac_deploy_trt/prepare.py | 7 +- .../src/isaac_deploy_trt/surgery.py | 10 +- .../src/isaac_deploy_trt/validate.py | 18 +++- .../tests/test_pipeline_merge.py | 2 +- pyproject.toml | 2 +- scripts/make_trt_aligned_leapp_bundle.py | 4 +- 17 files changed, 224 insertions(+), 118 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 4919d41c..8baf49d2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -21,7 +21,7 @@ Python 3.10+ and PyTorch 2.6.0+. Visualization extras install only on | Warp tracing (`TracedWpArray`, APIC, `warp_op`) | `warp_support.md` | | Public annotate/lifecycle API or docs examples | `docs/source/api/index.rst` plus the matching guide under `docs/source/` | | Graph PNG layout | `packages/leapp-visualization/` | -| TensorRT ONNX rewrite / catalog / pipeline merge | `packages/isaac_deploy_trt/` | +| TensorRT ONNX optimize / catalog / pipeline merge | `packages/isaac_deploy_trt/` | | Export backends | `leapp/backends/` | | YAML / `InferenceManager` | `leapp/leapp.py` (`compile_graph`, `optimize_graph`), `leapp/inference_manager.py`, `docs/source/generated_configs.rst` | @@ -42,7 +42,7 @@ leapp/ # installable package datatypes/ # TracedData, TracedTensor, TracedNpArray, TracedWpArray utils/ # logging, TensorSemantics, enums, GraphConfigs packages/leapp-visualization/ # static PNG layout (ships with leapp) -packages/isaac_deploy_trt/ # TensorRT ONNX rewrite, catalogs, merge-pipeline +packages/isaac_deploy_trt/ # TensorRT ONNX optimize, catalogs, merge-pipeline docs/source/ # Sphinx (NVIDIA theme) examples/ # runnable samples; CI runs tests/test_examples/ tests/ @@ -69,7 +69,7 @@ annotation APIs such as `method()`, `input_tensors()`, and ```bash python -m pip install -e ".[dev,test,warp-cu12]" # CUDA 12 python -m pip install -e ".[dev,test,warp-cu13]" # CUDA 13 -python -m pip install -e ".[dev,graph-surgery]" # TensorRT ONNX rewrite extras +python -m pip install -e ".[dev,graph-surgery]" # TensorRT ONNX optimize extras pytest tests/ packages/leapp-visualization/tests/ packages/isaac_deploy_trt/tests/ -v ``` @@ -82,7 +82,7 @@ Narrower (use these while iterating): | Annotate / I/O / state | `pytest tests/functional_tests/ -v` | | Examples | `pytest tests/test_examples/ -v` | | Visualization | `pytest packages/leapp-visualization/tests/ -v` (Python 3.11+) | -| TensorRT rewrite / catalogs | `pytest packages/isaac_deploy_trt/tests/ tests/unit_tests/test_optimize_graph.py tests/unit_tests/test_tensorrt_leapp_bundle.py -v` | +| TensorRT optimize / catalogs | `pytest packages/isaac_deploy_trt/tests/ tests/unit_tests/test_optimize_graph.py tests/unit_tests/test_tensorrt_leapp_bundle.py -v` | | Warp tracing | see `warp_support.md` | ### Warp runtime build @@ -152,7 +152,7 @@ diff (`git diff origin/main...HEAD`) is the true delta. | `guides/export.rst` | Backends and `export_with` | | `guides/graph.rst` | State, `annotate.module`, feedback | | `guides/buffers.rst` | `static_outputs`, `mirror_leapp_tags` | -| `guides/debugging.rst` | Validation, logs, dry_run, `non_traced`, TensorRT rewrite | +| `guides/debugging.rst` | Validation, logs, dry_run, `non_traced`, TensorRT optimize | | `leapp_runtime.rst` | `InferenceManager` | | `semantics/` | `TensorSemantics`, kinds, `TemporalAxis` | | `generated_configs.rst` | YAML shape | @@ -160,12 +160,16 @@ diff (`git diff origin/main...HEAD`) is the true delta. User-facing integration recipes belong here, not in this file. -TensorRT GraphSurgeon rewrites, op catalogs, and LEAPP DAG merge live in +TensorRT GraphSurgeon optimizations, op catalogs, and LEAPP DAG merge live in `packages/isaac_deploy_trt`. After `compile_graph()`, -`optimize_graph(trt_compatible=True)` rewrites ONNX in the graph directory -and updates YAML checksums / `parameters.tensorrt_compatible`. Merge a DAG +`optimize_graph(trt_compatible=True)` optimizes ONNX in the graph directory +and updates YAML checksums / `parameters.tensorrt_compatible`. When +`--tensorrt` is omitted, `check`, `optimize`, `merge-pipeline --optimize`, +and that optimize pass use the minimal catalog +(`tensorrt_catalogs/minimal/tensorrt_layers.json`): operators and native +layers supported by every checked-in release and platform. Merge a DAG for one Isaac `TensorRTNode` with -`isaac_deploy_trt merge-pipeline exported.yaml -o pipeline.onnx --rewrite`. +`isaac_deploy_trt merge-pipeline exported.yaml -o pipeline.onnx --optimize`. ## Guardrails when changing behavior diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index 479d0802..9e99d8f3 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -228,11 +228,15 @@ Signature Parameters ~~~~~~~~~~ -* ``trt_compatible`` (bool, optional): Rewrite exported ONNX files in the - graph output directory so TensorRT can parse them (UINT8 intermediate - Casts, Resize ``antialias``, rank-9 Reshape). Updates YAML checksums and - ``parameters.tensorrt_compatible``. Graph I/O names, dtypes, and shapes - are unchanged. Requires ``isaac_deploy_trt``. Defaults to ``False``. +* ``trt_compatible`` (bool, optional): Optimize exported ONNX files in the + graph output directory so TensorRT can parse them. Always edits UINT8 + intermediate Casts, Resize ``antialias``, and rank-9 Reshape. Also + decomposes operators the minimal TensorRT catalog marks unsupported. + That catalog is the intersection of every checked-in release and platform + (``tensorrt_catalogs/minimal/tensorrt_layers.json``). Updates YAML + checksums and ``parameters.tensorrt_compatible``. Graph I/O names, dtypes, + and shapes are unchanged. Requires ``isaac_deploy_trt``. Defaults to + ``False``. Behavior ~~~~~~~~ diff --git a/docs/source/generated_configs.rst b/docs/source/generated_configs.rst index d7d33e92..dcbd585c 100644 --- a/docs/source/generated_configs.rst +++ b/docs/source/generated_configs.rst @@ -151,13 +151,14 @@ The ``models`` mapping is deterministically ordered. LEAPP guarantees: ``tensorrt_compatible`` Present on ONNX backends unless ``backend_params={"annotate_tensorrt_compatible": False}``. - ``true`` means the exported graph's ops are in the TensorRT ONNX - support catalog (and, if ``validate_tensorrt_build`` was enabled, - TensorRT parsed/built the model). This does **not** switch the - runtime ``backend``; Isaac Deploy / Triton still load ``backend: onnx`` - unless the deployer maps this flag itself. Catalog ``true`` is not a - guarantee that TensorRT can build engines with dynamic shapes or - shape-tensor inputs without optimization profiles. + ``true`` means every ONNX operator in the exported graph is supported + by the minimal TensorRT catalog: the intersection of every checked-in + release and platform. If ``validate_tensorrt_build`` was enabled, it + also means the installed TensorRT package parsed and built the model. + This does **not** switch the runtime ``backend``; Isaac Deploy / Triton + still load ``backend: onnx`` unless the deployer maps this flag itself. + Catalog ``true`` is not a guarantee that TensorRT can build engines + with dynamic shapes or shape-tensor inputs without optimization profiles. ``pipeline`` ------------ diff --git a/docs/source/guides/debugging.rst b/docs/source/guides/debugging.rst index a08b0112..a08f55e7 100644 --- a/docs/source/guides/debugging.rst +++ b/docs/source/guides/debugging.rst @@ -177,30 +177,42 @@ LEAPP patches for the tracing session (for example NumPy and torch interop). Use this only to test whether those patches are involved in a failure. -TensorRT catalog and rewrite -============================ +TensorRT catalog and optimize +============================== -TensorRT op-catalog checks, GraphSurgeon rewrites, and DAG merge live in +TensorRT op-catalog checks, GraphSurgeon optimizations, and DAG merge live in the in-tree ``isaac_deploy_trt`` package (also the ``graph-surgery`` extra), -not in the LEAPP tracing CLI. After ``compile_graph()``, rewrite exported +not in the LEAPP tracing CLI. After ``compile_graph()``, optimize exported ONNX in place with ``leapp.optimize_graph(trt_compatible=True)``. That updates YAML checksums and ``parameters.tensorrt_compatible``. +With no ``--tensorrt`` flag, ``check``, ``optimize``, ``optimize-dir``, and +``merge-pipeline --optimize`` use the minimal catalog, +``tensorrt_catalogs/minimal/tensorrt_layers.json``. An ONNX operator or +native layer counts as supported only when every checked-in TensorRT release +and platform marks it supported. ``leapp.optimize_graph(trt_compatible=True)`` +uses that catalog for unsupported-operator optimizations. UINT8 intermediate +Casts, Resize ``antialias``, and rank-9 Reshape edits always run. + +``--tensorrt`` selects one release, for example ``10.16``. ``--platform`` +(``x86``, ``orin``, ``thor``, or ``dgx``) applies only together with +``--tensorrt``. ``--tensorrt 11.2`` with no platform uses the built-in 11.2 +parser table. ``--catalog`` replaces those flags with one JSON file. + .. code-block:: bash pip install -e ".[graph-surgery]" isaac_deploy_trt check --onnx path/to/model.onnx --strict isaac_deploy_trt check --onnx path/to/model.onnx --tensorrt 10.16 --platform orin --strict isaac_deploy_trt check --onnx-dir path/to/export_dir --build --strict - isaac_deploy_trt rewrite-dir path/to/export_dir -o path/to/export_dir_trt --tensorrt 10.16 --platform orin - isaac_deploy_trt merge-pipeline path/to/export.yaml -o pipeline.onnx --rewrite + isaac_deploy_trt optimize-dir path/to/export_dir -o path/to/export_dir_trt + isaac_deploy_trt optimize-dir path/to/export_dir -o path/to/export_dir_trt --tensorrt 10.16 --platform orin + isaac_deploy_trt merge-pipeline path/to/export.yaml -o pipeline.onnx --optimize ``--build`` also runs TensorRT parse/build (requires ``tensorrt``). ``--strict`` exits non-zero if catalog or TensorRT checks fail. -``--tensorrt`` selects a release catalog such as ``10.16``; ``--platform`` -is ``x86``, ``orin``, ``thor``, or ``dgx``. Omitting both keeps the baked-in -TensorRT 11.2 operator table. -Set ``backend_params={"annotate_tensorrt_compatible": False}`` to omit the -YAML field, or ``{"validate_tensorrt": True, "validate_tensorrt_build": True}`` +The YAML field ``parameters.tensorrt_compatible`` uses the same minimal +catalog. Set ``backend_params={"annotate_tensorrt_compatible": False}`` to +omit it, or ``{"validate_tensorrt": True, "validate_tensorrt_build": True}`` to require a TensorRT parse/build before marking ``true``. diff --git a/leapp/backends/tensorrt_leapp_bundle.py b/leapp/backends/tensorrt_leapp_bundle.py index c38f1da2..260d394d 100644 --- a/leapp/backends/tensorrt_leapp_bundle.py +++ b/leapp/backends/tensorrt_leapp_bundle.py @@ -23,7 +23,7 @@ import onnx import yaml -from isaac_deploy_trt.prepare import needs_tensorrt_rewrite +from isaac_deploy_trt.prepare import needs_tensorrt_rewrite, surgeon_ops_for_target from isaac_deploy_trt.surgery import ( apply_tensorrt_rewrites, export_model, @@ -201,6 +201,7 @@ def align_leapp_export_for_tensorrt( result = AlignedBundleResult(output_dir=output_dir) hashes: Dict[str, tuple[str, str]] = {} trt_compatible: Dict[str, bool] = {} + surgeon_ops, _catalog = surgeon_ops_for_target() for src in onnx_files: filename = os.path.basename(src) @@ -208,13 +209,13 @@ def align_leapp_export_for_tensorrt( source_model = onnx.load(src, load_external_data=False) source_io = graph_io_signature(source_model) - if not needs_tensorrt_rewrite(source_model): + if not needs_tensorrt_rewrite(source_model, surgeon_ops=surgeon_ops): _copy_with_external_data(src, dst) logger.info(f"Copied {filename} (already TensorRT-aligned I/O)") rewritten_nodes: List[str] = [] else: graph = load_graph(src) - rewritten_nodes = apply_tensorrt_rewrites(graph) + rewritten_nodes = apply_tensorrt_rewrites(graph, surgeon_ops=surgeon_ops) _save_rewritten(graph, src, dst) aligned = onnx.load(dst, load_external_data=False) aligned_io = graph_io_signature(aligned) diff --git a/leapp/cli.py b/leapp/cli.py index b1e4995b..b75ab487 100644 --- a/leapp/cli.py +++ b/leapp/cli.py @@ -5,14 +5,14 @@ """LEAPP command-line entry point. -TensorRT ONNX rewrite, catalog check, and pipeline merge live in the sibling +TensorRT ONNX optimize, catalog check, and pipeline merge live in the sibling ``isaac_deploy_trt`` package:: pip install -e ./packages/isaac_deploy_trt isaac_deploy_trt check --onnx model.onnx --strict isaac_deploy_trt check --onnx-dir ./exported_graph --build --strict - isaac_deploy_trt rewrite-dir ./exported_graph -o ./exported_graph_trt - isaac_deploy_trt merge-pipeline exported.yaml -o pipeline.onnx --rewrite + isaac_deploy_trt optimize-dir ./exported_graph -o ./exported_graph_trt + isaac_deploy_trt merge-pipeline exported.yaml -o pipeline.onnx --optimize """ from __future__ import annotations @@ -25,8 +25,8 @@ pip install -e ./packages/isaac_deploy_trt isaac_deploy_trt check --onnx MODEL.onnx [--build] [--strict] isaac_deploy_trt check --onnx-dir EXPORT_DIR [--build] [--strict] - isaac_deploy_trt rewrite-dir INPUT_DIR -o OUTPUT_DIR - isaac_deploy_trt merge-pipeline EXPORTED.yaml -o pipeline.onnx [--rewrite] + isaac_deploy_trt optimize-dir INPUT_DIR -o OUTPUT_DIR + isaac_deploy_trt merge-pipeline EXPORTED.yaml -o pipeline.onnx [--optimize] """ diff --git a/leapp/leapp.py b/leapp/leapp.py index d834cba6..905ecf68 100644 --- a/leapp/leapp.py +++ b/leapp/leapp.py @@ -205,9 +205,9 @@ def optimize_graph(trt_compatible=False): """Post-compile optimizations for the saved LEAPP graph. Call after ``compile_graph()``. Options can be combined as more passes are - added; today ``trt_compatible`` is the TensorRT ONNX rewrite pass. + added; today ``trt_compatible`` is the TensorRT ONNX optimize pass. - When ``trt_compatible=True``, LEAPP rewrites exported ONNX files in the + When ``trt_compatible=True``, LEAPP optimizes exported ONNX files in the graph output directory so TensorRT can parse them (UINT8 intermediate Casts, Resize ``antialias``, rank-9 Reshape) and updates YAML checksums plus ``parameters.tensorrt_compatible``. Graph input/output names, dtypes, @@ -254,18 +254,18 @@ def optimize_graph(trt_compatible=False): rewritten = [model.filename for model in result.models if model.rewritten] if rewritten: _get_logger().info( - f"Rewrote ONNX for TensorRT: {', '.join(rewritten)}" + f"Optimized ONNX for TensorRT: {', '.join(rewritten)}" ) else: _get_logger().info( - "No TensorRT GraphSurgeon rewrites were needed for exported ONNX" + "No TensorRT GraphSurgeon optimizations were needed for exported ONNX" ) applied["trt_compatible"] = result if not applied: _get_logger().warning( "leapp.optimize_graph() ran with no optimization options enabled. " - "Pass trt_compatible=True to rewrite ONNX for TensorRT." + "Pass trt_compatible=True to optimize ONNX for TensorRT." ) return applied diff --git a/packages/isaac_deploy_trt/README.md b/packages/isaac_deploy_trt/README.md index 9fdd01c9..1cce5c2d 100644 --- a/packages/isaac_deploy_trt/README.md +++ b/packages/isaac_deploy_trt/README.md @@ -1,6 +1,6 @@ # isaac_deploy_trt -Standalone GraphSurgeon toolkit that applies the same TensorRT ONNX rewrites +Standalone GraphSurgeon toolkit that applies the same TensorRT ONNX optimizations used in LEAPP, without depending on LEAPP export/tracing. Given an ONNX file (or a directory of them), it: @@ -54,24 +54,24 @@ pip install -e "./packages/isaac_deploy_trt[dev]" ## Commands -### Rewrite one file +### Optimize one file ```bash -isaac_deploy_trt rewrite IN.onnx -o OUT.onnx +isaac_deploy_trt optimize IN.onnx -o OUT.onnx # TensorRT 10.16, Jetson Orin catalog -isaac_deploy_trt rewrite IN.onnx -o OUT.onnx --tensorrt 10.16 --platform orin +isaac_deploy_trt optimize IN.onnx -o OUT.onnx --tensorrt 10.16 --platform orin ``` Example (the only Apple PnP node that currently needs surgery): ```bash -isaac_deploy_trt rewrite \ +isaac_deploy_trt optimize \ /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx/preprocess_video.onnx \ -o /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx_surgeon/preprocess_video.onnx ``` -### Rewrite a directory into another folder +### Optimize a directory into another folder Copies every `*.onnx` (and matching `.onnx.data`) into `-o`. Only graphs that hit the three patterns above are edited. @@ -79,19 +79,21 @@ hit the three patterns above are edited. `-o` **must not** be the input directory. ```bash -isaac_deploy_trt rewrite-dir INPUT_DIR -o OUTPUT_DIR --tensorrt 10.16 --platform orin +isaac_deploy_trt optimize-dir INPUT_DIR -o OUTPUT_DIR --tensorrt 10.16 --platform orin ``` ``--tensorrt`` and ``--platform`` select the operator catalog, the same way they do for ``check``. Unsupported-op decomposition runs only for operators that catalog marks unsupported. UINT8 Cast, Resize antialias, and Reshape rank -edits still run. ``--platform`` is ``x86`` (default), ``orin``, ``thor``, or -``dgx``. Omitting both flags rewrites every operator that has a decomposition. +edits still run. ``--platform`` is ``x86``, ``orin``, ``thor``, or ``dgx``, and applies with ``--tensorrt``. +Omitting ``--tensorrt`` uses the minimal catalog, the operators unsupported +on every checked-in TensorRT release. ``merge-pipeline --optimize`` uses that +same default. GR00T Apple PnP LEAPP pack: ```bash -isaac_deploy_trt rewrite-dir \ +isaac_deploy_trt optimize-dir \ /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx \ -o /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx_surgeon ``` @@ -100,20 +102,21 @@ For `nvidia/GR00T-N1.7-ApplePnP-V1` as exported today: | File | Surgeon | |---|---| -| `preprocess_video.onnx` | rewrite (UINT8 Cast, Resize antialias, rank-9 Reshape) | +| `preprocess_video.onnx` | optimize (UINT8 Cast, Resize antialias, rank-9 Reshape) | | `preprocess_state.onnx` | copy | | `backbone.onnx` | copy | | `action_head.onnx` | copy | | `decode_action.onnx` | copy | -YAML (`exported_leapp.yaml`) is **not** copied by `rewrite-dir`. Copy it +YAML (`exported_leapp.yaml`) is **not** copied by `optimize-dir`. Copy it yourself if you need a full deploy tree. ### List ONNX operators TensorRT does not support Prints the static parser table (onnx-tensorrt `operators.md`). No ONNX file -and no Triton / ONNX Runtime install. This is the same table `check` uses -when it marks an op unsupported. +and no Triton / ONNX Runtime install. With no flags this is the TensorRT 11.2 +table. `check`, `optimize`, and `merge-pipeline --optimize` use the minimal +catalog unless `--tensorrt` or `--catalog` is set. ```bash isaac_deploy_trt unsupported-ops @@ -131,10 +134,11 @@ python scripts/list_unsupported_onnx_ops.py ### Catalog-check ONNX (validate) Static check: ops in the graph vs a TensorRT operator catalog. -Does **not** rewrite files. With no version flag, the baked-in TensorRT 11.2 -`operators.md` table is used. `--tensorrt` loads that release from +Does **not** optimize files. With no version flag, the minimal catalog is used: +an operator counts as supported only when every checked-in TensorRT release +marks it supported. `--tensorrt` loads that release from `tensorrt_catalogs/` (`10.16` and `v10.16` both work). `--platform` selects -`x86` (default), `orin`, `thor`, or `dgx`. `--catalog` points at one JSON +`x86`, `orin`, `thor`, or `dgx` for that release. `--catalog` points at one JSON file and replaces the version flags. Does **not** catch UINT8 Cast / Resize antialias / rank-9 Reshape. Those only @@ -182,8 +186,10 @@ merged protobuf (does not load the 6 GB GR00T backbone into RAM). isaac_deploy_trt merge-pipeline EXPORTED.yaml -o pipeline.onnx ``` -``--rewrite`` applies the GraphSurgeon TensorRT edits to each subgraph before -merge (needed if you have not already run ``rewrite-dir``). +``--optimize`` applies the GraphSurgeon TensorRT edits to each subgraph before +merge (needed if you have not already run ``optimize-dir``). With no +``--tensorrt`` flag it uses the minimal catalog, the same default as +``check`` and ``optimize``. ``--model-dir`` defaults to the YAML directory. ``--yaml-out`` overrides the sibling ``pipeline.yaml`` (TensorRTNode ``input_tensor_names`` / @@ -192,7 +198,7 @@ sibling ``pipeline.yaml`` (TensorRTNode ``input_tensor_names`` / Standalone script (same flags after the YAML path): ```bash -python scripts/merge_pipeline.py EXPORTED.yaml -o pipeline.onnx --rewrite +python scripts/merge_pipeline.py EXPORTED.yaml -o pipeline.onnx --optimize ``` GR00T Apple PnP (rewritten video preprocess + merge): @@ -202,7 +208,7 @@ isaac_deploy_trt merge-pipeline \ /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx/exported_leapp.yaml \ --model-dir /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_onnx \ -o /mnt/sdb2/workspaces/leapp/gr00t-leapp-export/apple_pnp_pipeline/pipeline.onnx \ - --rewrite + --optimize ``` Then build the engine on the target GPU: @@ -258,6 +264,23 @@ isaac_deploy_trt generate -o tensorrt_catalogs --print-summary \ Checked-in databases live in [`tensorrt_catalogs/`](tensorrt_catalogs/index.json). Look up a GitHub tag in `release_to_database`, then open that directory. +Each database is one JSON object per platform. Native layers are +`tensorrt_layers` (`gpu`, `dla`, `notes`). ONNX parser ops are +`onnx_operators` (`supported`, `types`, `restrictions`). + +The minimal catalog is `tensorrt_catalogs/minimal/tensorrt_layers.json`. +It is the default for `check`, `optimize`, `optimize-dir`, and +`merge-pipeline --optimize` when `--tensorrt` is omitted, and for +`leapp.optimize_graph(trt_compatible=True)`. A native layer is included +only when every checked-in catalog sets `gpu: true`. `onnx_operators` is +the same intersection: an operator is supported only when every catalog +marks it supported. + +```bash +isaac_deploy_trt minimal-layers +isaac_deploy_trt minimal-layers -o tensorrt_catalogs/minimal/tensorrt_layers.json +``` + There are no public `v11.3` / `v11.4` tags. Latest OSS 11.x tags are `v11.0`, `v11.1`, `v11.2`. @@ -265,6 +288,8 @@ There are no public `v11.3` / `v11.4` tags. Latest OSS 11.x tags are `v11.0`, ## Python +These helpers are what `optimize` and `optimize-dir` call. + ```python from isaac_deploy_trt import rewrite_onnx_file, rewrite_directory diff --git a/packages/isaac_deploy_trt/pyproject.toml b/packages/isaac_deploy_trt/pyproject.toml index 967d3bd7..bbeae8d7 100644 --- a/packages/isaac_deploy_trt/pyproject.toml +++ b/packages/isaac_deploy_trt/pyproject.toml @@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta" [project] name = "isaac_deploy_trt" version = "0.1.0" -description = "GraphSurgeon ONNX rewrites to make models TensorRT-parseable" +description = "GraphSurgeon ONNX optimizations to make models TensorRT-parseable" readme = "README.md" license = "Apache-2.0" requires-python = ">=3.10" diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py index 78274dd0..4375f9fb 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/cli.py @@ -3,11 +3,12 @@ # SPDX-License-Identifier: Apache-2.0 # -"""CLI: rewrite / check ONNX models for TensorRT.""" +"""CLI: optimize / check ONNX models for TensorRT.""" from __future__ import annotations import argparse +import json import logging import os import sys @@ -20,6 +21,7 @@ save_merged_pipeline, ) from isaac_deploy_trt.prepare import rewrite_directory, rewrite_onnx_file +from isaac_deploy_trt.minimal_layers import format_minimal_layers, minimal_supported_layers from isaac_deploy_trt.unsupported_cmd import add_unsupported_arguments, run_unsupported from isaac_deploy_trt.validate import validate_onnx_for_tensorrt @@ -34,46 +36,47 @@ def _add_target_arguments(parser: argparse.ArgumentParser) -> None: default=None, help=( "TensorRT release for the operator catalog (for example 10.16 or 11.2). " - "Unsupported-op rewrites follow that catalog. " - "Default: rewrite every operator that has a decomposition." + "Unsupported-op optimizations follow that catalog. " + "Default: the minimal catalog, operators unsupported on every checked-in TensorRT release." ), ) parser.add_argument( "--platform", default=None, help=( - "Platform overlay when selecting a tensorrt_catalogs file: " - "x86, orin, thor, or dgx. Default: x86." + "Platform overlay for a --tensorrt release: " + "x86, orin, thor, or dgx. Default with --tensorrt: x86. " + "Ignored when --tensorrt is omitted." ), ) -def _rewrite_kwargs(args: argparse.Namespace) -> dict: +def _optimize_kwargs(args: argparse.Namespace) -> dict: return {"tensorrt": args.tensorrt, "platform": args.platform} -def _cmd_rewrite(args: argparse.Namespace) -> int: +def _cmd_optimize(args: argparse.Namespace) -> int: try: - result = rewrite_onnx_file(args.onnx, args.output, **_rewrite_kwargs(args)) + result = rewrite_onnx_file(args.onnx, args.output, **_optimize_kwargs(args)) except (KeyError, ValueError, FileNotFoundError) as exc: print(f"error: {exc}", file=sys.stderr) return 2 - action = "rewrote" if result.rewritten else "copied" + action = "optimized" if result.rewritten else "copied" extra = f" ({len(result.rewritten_nodes)} nodes)" if result.rewritten else "" suffix = f" [{result.catalog_path}]" if result.catalog_path else "" print(f"{action} {result.filename}{extra} -> {result.output_path}{suffix}") return 0 -def _cmd_rewrite_dir(args: argparse.Namespace) -> int: +def _cmd_optimize_dir(args: argparse.Namespace) -> int: try: - results = rewrite_directory(args.input_dir, args.output, **_rewrite_kwargs(args)) + results = rewrite_directory(args.input_dir, args.output, **_optimize_kwargs(args)) except (KeyError, ValueError, FileNotFoundError) as exc: print(f"error: {exc}", file=sys.stderr) return 2 print(f"Wrote {len(results)} ONNX file(s) to {os.path.abspath(args.output)}") for item in results: - action = "rewrote" if item.rewritten else "copied" + action = "optimized" if item.rewritten else "copied" extra = f" ({len(item.rewritten_nodes)} nodes)" if item.rewritten else "" suffix = f" [{item.catalog_path}]" if item.catalog_path else "" print(f" {action} {item.filename}{extra}{suffix}") @@ -89,7 +92,7 @@ def _cmd_merge_pipeline(args: argparse.Namespace) -> int: result = merge_leapp_onnx_pipeline( yaml_path, model_dir=args.model_dir, - rewrite=args.rewrite, + optimize=args.optimize, ) out_yaml = save_merged_pipeline( result, @@ -100,7 +103,7 @@ def _cmd_merge_pipeline(args: argparse.Namespace) -> int: logging.getLogger(__name__).error("Failed to merge LEAPP pipeline: %s", exc) return 1 if result.rewritten_models: - print(f"rewrote before merge: {', '.join(result.rewritten_models)}") + print(f"optimized before merge: {', '.join(result.rewritten_models)}") print(f"wrote {os.path.abspath(os.path.expanduser(args.output))}") print(f"wrote {out_yaml}") print(f"TensorRTNode inputs: {result.input_tensor_names}") @@ -147,6 +150,26 @@ def _cmd_check(args: argparse.Namespace) -> int: return 0 +def _cmd_minimal_layers(args: argparse.Namespace) -> int: + try: + report = minimal_supported_layers() + except (OSError, ValueError, json.JSONDecodeError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 2 + if args.output: + path = os.path.abspath(os.path.expanduser(args.output)) + os.makedirs(os.path.dirname(path) or ".", exist_ok=True) + with open(path, "w", encoding="utf-8") as handle: + json.dump(report, handle, indent=2) + handle.write("\n") + print(f"wrote {path}") + print(f" layers: {report['layer_count']}") + print(f" excluded: {len(report['excluded'])}") + return 0 + print(format_minimal_layers(report)) + return 0 + + def _cmd_catalog(args: argparse.Namespace) -> int: releases = [] if args.releases: @@ -192,7 +215,7 @@ def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser( prog="isaac_deploy_trt", description=( - "GraphSurgeon ONNX rewrites for TensorRT: UINT8 intermediate Casts, " + "GraphSurgeon ONNX optimizations for TensorRT: UINT8 intermediate Casts, " "Resize antialias, Reshape rank > 8. Graph I/O names are preserved. " "Merge a LEAPP YAML DAG into one ONNX graph for TensorRTNode. " "Also join operators.md with NvInfer.h DataType/LayerType catalogs, " @@ -201,19 +224,19 @@ def main(argv: list[str] | None = None) -> int: ) sub = parser.add_subparsers(dest="command", required=True) - rewrite = sub.add_parser("rewrite", help="Rewrite one ONNX file") - rewrite.add_argument("onnx", help="Input .onnx path") - rewrite.add_argument("-o", "--output", required=True, help="Output .onnx path") - _add_target_arguments(rewrite) - rewrite.set_defaults(handler=_cmd_rewrite) + optimize = sub.add_parser("optimize", help="Optimize one ONNX file") + optimize.add_argument("onnx", help="Input .onnx path") + optimize.add_argument("-o", "--output", required=True, help="Output .onnx path") + _add_target_arguments(optimize) + optimize.set_defaults(handler=_cmd_optimize) - rewrite_dir = sub.add_parser( - "rewrite-dir", help="Rewrite every .onnx in a directory" + optimize_dir = sub.add_parser( + "optimize-dir", help="Optimize every .onnx in a directory" ) - rewrite_dir.add_argument("input_dir", help="Directory of .onnx files") - rewrite_dir.add_argument("-o", "--output", required=True, help="Output directory") - _add_target_arguments(rewrite_dir) - rewrite_dir.set_defaults(handler=_cmd_rewrite_dir) + optimize_dir.add_argument("input_dir", help="Directory of .onnx files") + optimize_dir.add_argument("-o", "--output", required=True, help="Output directory") + _add_target_arguments(optimize_dir) + optimize_dir.set_defaults(handler=_cmd_optimize_dir) merge = sub.add_parser( "merge-pipeline", @@ -240,10 +263,11 @@ def main(argv: list[str] | None = None) -> int: help="Optional path for the single-model YAML / TensorRTNode name lists", ) merge.add_argument( - "--rewrite", + "--optimize", action="store_true", help=( - "Apply TensorRT GraphSurgeon rewrites to each subgraph before merge" + "Apply TensorRT GraphSurgeon optimizations to each subgraph before merge. " + "Uses the minimal catalog." ), ) merge.set_defaults(handler=_cmd_merge_pipeline) @@ -259,15 +283,17 @@ def main(argv: list[str] | None = None) -> int: default=None, help=( "TensorRT release for the operator catalog (for example 10.16 or 11.2). " - "Default: baked-in 11.2 parser table. Other releases load tensorrt_catalogs." + "Default: the minimal catalog shared by every checked-in release. " + "Other releases load tensorrt_catalogs." ), ) check.add_argument( "--platform", default=None, help=( - "Platform overlay when selecting a tensorrt_catalogs file: " - "x86, orin, thor, or dgx. Default: x86." + "Platform overlay for a --tensorrt release: " + "x86, orin, thor, or dgx. Default with --tensorrt: x86. " + "Ignored when --tensorrt is omitted." ), ) check.add_argument( @@ -289,6 +315,18 @@ def main(argv: list[str] | None = None) -> int: add_unsupported_arguments(unsupported) unsupported.set_defaults(handler=run_unsupported) + minimal = sub.add_parser( + "minimal-layers", + help="List native layers supported by every checked-in TensorRT catalog", + ) + minimal.add_argument( + "-o", + "--output", + default=None, + help="Write the minimal layer catalog JSON to this path", + ) + minimal.set_defaults(handler=_cmd_minimal_layers) + catalog = sub.add_parser( "catalog", help="Join operators.md with TensorRT header enumerations", diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py index 33ac4d2a..16cee51c 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/pipeline_merge.py @@ -29,7 +29,7 @@ import yaml from onnx import compose, helper -from isaac_deploy_trt.prepare import needs_tensorrt_rewrite +from isaac_deploy_trt.prepare import needs_tensorrt_rewrite, surgeon_ops_for_target from isaac_deploy_trt.surgery import rewrite_onnx_for_tensorrt logger = logging.getLogger(__name__) @@ -174,15 +174,16 @@ def merge_leapp_onnx_pipeline( yaml_path: str, *, model_dir: Optional[str] = None, - rewrite: bool = False, + optimize: bool = False, ) -> MergedPipelineResult: """Build one ONNX graph from a LEAPP export YAML and sibling ``.onnx`` files. ``model_dir`` defaults to the YAML's directory. Relative ``parameters.model_path`` values are resolved against that directory. - If ``rewrite`` is true, apply TensorRT GraphSurgeon edits (UINT8 Cast, - Resize antialias, rank>8 Reshape) to each subgraph before inlining. + If ``optimize`` is true, apply TensorRT GraphSurgeon edits (UINT8 Cast, + Resize antialias, rank>8 Reshape, and operators the minimal catalog marks + unsupported) to each subgraph before inlining. """ yaml_path = os.path.abspath(yaml_path) model_dir = os.path.abspath(model_dir or os.path.dirname(yaml_path)) @@ -206,6 +207,9 @@ def merge_leapp_onnx_pipeline( ir_version = 0 external_data_sources: Dict[str, str] = {} rewritten_models: List[str] = [] + surgeon_ops = None + if optimize: + surgeon_ops, _catalog = surgeon_ops_for_target() for name, cfg in models_cfg.items(): rel = ((cfg or {}).get("parameters") or {}).get("model_path", "") if not rel: @@ -215,9 +219,9 @@ def merge_leapp_onnx_pipeline( raise FileNotFoundError(f"ONNX for model {name!r} not found: {path}") logger.info("Loading %s from %s", name, path) raw = _load_model(path) - if rewrite and needs_tensorrt_rewrite(raw): - logger.info("Rewriting %s for TensorRT before merge", name) - raw = rewrite_onnx_for_tensorrt(raw) + if optimize and needs_tensorrt_rewrite(raw, surgeon_ops=surgeon_ops): + logger.info("Optimizing %s for TensorRT before merge", name) + raw = rewrite_onnx_for_tensorrt(raw, surgeon_ops=surgeon_ops) rewritten_models.append(name) for location in _external_locations(raw): source = os.path.abspath(os.path.join(os.path.dirname(path), location)) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py index a0c03dc8..29f587f5 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/prepare.py @@ -56,11 +56,10 @@ def surgeon_ops_for_target( ) -> Tuple[Optional[frozenset], Optional[str]]: """Return surgeon ops the selected catalog marks unsupported, plus its path. - ``(None, None)`` keeps the full decomposition set used when no TensorRT - release is requested. + No TensorRT release selects the minimal catalog: an operator is decomposed + only when it is unsupported in every checked-in TensorRT catalog and a + GraphSurgeon rewrite exists. ``--platform`` applies only with ``--tensorrt``. """ - if tensorrt is None and platform is None and cuda is None and catalog is None: - return None, None ops_map, catalog_path = select_onnx_ops( tensorrt=tensorrt, cuda=cuda, diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py index 652bd0ce..111f50a1 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/surgery.py @@ -631,6 +631,7 @@ def _entries(infos) -> List[tuple]: def rewrite_onnx_for_tensorrt( model_or_path: Union[str, ModelProto], output_path: Optional[str] = None, + surgeon_ops: Optional[Sequence[str]] = None, ) -> ModelProto: """Apply GraphSurgeon rewrites that unblock TensorRT parse for typical ONNX graphs. @@ -638,9 +639,16 @@ def rewrite_onnx_for_tensorrt( intermediate Casts → INT32, Resize ``antialias`` → 0, and Reshape rank > 8 lowered by dropping extent-1 axes. Graph I/O names, dtypes, and shapes are left unchanged so downstream YAML / Triton bindings stay valid. + + ``surgeon_ops`` limits which unsupported operators are decomposed. When it + is omitted, the minimal catalog is used. """ + if surgeon_ops is None: + from isaac_deploy_trt.prepare import surgeon_ops_for_target + + surgeon_ops, _catalog = surgeon_ops_for_target() graph = load_graph(model_or_path) - apply_tensorrt_rewrites(graph) + apply_tensorrt_rewrites(graph, surgeon_ops=surgeon_ops) if output_path is not None: save_graph(graph, output_path) return onnx.load(output_path) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py index d8a2b73b..323895aa 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py @@ -158,10 +158,12 @@ def select_onnx_ops( ) -> tuple[Dict[str, dict], Optional[str]]: """Return ``(operator map, catalog path)``. - The baked-in parser table is used when no version, platform, or catalog - file is requested, and when ``--tensorrt`` names that table (currently - 11.2) without a platform overlay. Any other release is loaded from - ``tensorrt_catalogs``. + With no TensorRT version and no catalog file, the minimal catalog is used: + an operator counts as supported only when every checked-in release and + platform marks it supported. ``--tensorrt 11.2`` without a platform still + uses the baked-in 11.2 parser table. Any other release is loaded from + ``tensorrt_catalogs``. ``--platform`` and ``--cuda`` apply only together + with ``--tensorrt``. """ if catalog: path = Path(catalog).expanduser().resolve() @@ -169,6 +171,14 @@ def select_onnx_ops( raise FileNotFoundError(f"Catalog not found: {path}") return _ops_from_catalog_file(path), str(path) + if tensorrt is None: + from isaac_deploy_trt.minimal_layers import minimal_catalog_path + + path = minimal_catalog_path() + if not path.is_file(): + raise FileNotFoundError(f"Minimal TensorRT catalog not found: {path}") + return _ops_from_catalog_file(path), str(path) + if platform is None and catalog is None: try: return onnx_ops_for_version(tensorrt, cuda=cuda), None diff --git a/packages/isaac_deploy_trt/tests/test_pipeline_merge.py b/packages/isaac_deploy_trt/tests/test_pipeline_merge.py index 483f8953..b33b12b9 100644 --- a/packages/isaac_deploy_trt/tests/test_pipeline_merge.py +++ b/packages/isaac_deploy_trt/tests/test_pipeline_merge.py @@ -234,7 +234,7 @@ def test_rewrite_during_merge(self): yaml_path = os.path.join(tmp, "exported.yaml") with open(yaml_path, "w", encoding="utf-8") as handle: yaml.safe_dump(spec, handle) - result = merge_leapp_onnx_pipeline(yaml_path, rewrite=True) + result = merge_leapp_onnx_pipeline(yaml_path, optimize=True) self.assertEqual(result.rewritten_models, ["pre"]) resize_nodes = [ node for node in result.model.graph.node if node.op_type == "Resize" diff --git a/pyproject.toml b/pyproject.toml index e5ef215f..977f4edc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -112,7 +112,7 @@ script-files = [ ] [tool.setuptools.packages.find] -# Include internal visualization and TensorRT rewrite modules shipped with leapp. +# Include internal visualization and TensorRT optimize modules shipped with leapp. where = [".", "packages/leapp-visualization/src", "packages/isaac_deploy_trt/src"] include = ["leapp*", "leapp_visualization*", "isaac_deploy_trt*"] exclude = ["tests*"] diff --git a/scripts/make_trt_aligned_leapp_bundle.py b/scripts/make_trt_aligned_leapp_bundle.py index 6155ef0e..d217f0cf 100644 --- a/scripts/make_trt_aligned_leapp_bundle.py +++ b/scripts/make_trt_aligned_leapp_bundle.py @@ -7,7 +7,7 @@ """Write a LEAPP export dir with TensorRT-legal ONNX under the original names. Isaac Deploy / Triton look up ``preprocess_video.onnx``, ``backbone.onnx``, -etc. next to the YAML. This copies that layout and only rewrites graphs that +etc. next to the YAML. This copies that layout and only optimizes graphs that need GraphSurgeon (UINT8 Cast, Resize antialias, rank-9 Reshape). Checksums in the YAML are updated. Graph I/O names/shapes/dtypes are unchanged. @@ -44,7 +44,7 @@ def main(argv: list[str] | None = None) -> int: result = align_leapp_export_for_tensorrt(args.export_dir, args.output) print(f"Wrote aligned TensorRT LEAPP bundle to {result.output_dir}") for model in result.models: - action = "rewrote" if model.rewritten else "copied" + action = "optimized" if model.rewritten else "copied" extra = f" ({len(model.rewritten_nodes)} nodes)" if model.rewritten else "" print(f" {action} {model.filename}{extra}") return 0 From 7e5cad3a2260a5e30d4c7c52e044deacc6233b0c Mon Sep 17 00:00:00 2001 From: Tao Zhang Date: Mon, 26 Oct 2026 18:26:57 -0400 Subject: [PATCH 5/5] feat: add the minimal TensorRT catalog omitted from Cleanup Signed-off-by: Tao Zhang --- AGENTS.md | 3 +- docs/source/api/index.rst | 3 +- docs/source/generated_configs.rst | 9 +- docs/source/guides/debugging.rst | 11 +- leapp/backends/onnx_export_backend.py | 28 +- leapp/backends/tensorrt_leapp_bundle.py | 28 +- leapp/leapp.py | 3 +- .../src/isaac_deploy_trt/minimal_layers.py | 167 ++ .../src/isaac_deploy_trt/validate.py | 29 + .../minimal/tensorrt_layers.json | 2186 +++++++++++++++++ .../tests/test_check_version.py | 131 + .../tests/test_minimal_layers.py | 60 + .../unit_tests/test_tensorrt_leapp_bundle.py | 31 +- 13 files changed, 2665 insertions(+), 24 deletions(-) create mode 100644 packages/isaac_deploy_trt/src/isaac_deploy_trt/minimal_layers.py create mode 100644 packages/isaac_deploy_trt/tensorrt_catalogs/minimal/tensorrt_layers.json create mode 100644 packages/isaac_deploy_trt/tests/test_check_version.py create mode 100644 packages/isaac_deploy_trt/tests/test_minimal_layers.py diff --git a/AGENTS.md b/AGENTS.md index 8baf49d2..4aa62dc6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -163,7 +163,8 @@ User-facing integration recipes belong here, not in this file. TensorRT GraphSurgeon optimizations, op catalogs, and LEAPP DAG merge live in `packages/isaac_deploy_trt`. After `compile_graph()`, `optimize_graph(trt_compatible=True)` optimizes ONNX in the graph directory -and updates YAML checksums / `parameters.tensorrt_compatible`. When +and updates YAML checksums / `parameters.optimization` / +`parameters.tensorrt_version`. When `--tensorrt` is omitted, `check`, `optimize`, `merge-pipeline --optimize`, and that optimize pass use the minimal catalog (`tensorrt_catalogs/minimal/tensorrt_layers.json`): operators and native diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index 9e99d8f3..dd69d906 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -234,7 +234,8 @@ Parameters decomposes operators the minimal TensorRT catalog marks unsupported. That catalog is the intersection of every checked-in release and platform (``tensorrt_catalogs/minimal/tensorrt_layers.json``). Updates YAML - checksums and ``parameters.tensorrt_compatible``. Graph I/O names, dtypes, + checksums, ``parameters.optimization``, and ``parameters.tensorrt_version``. + Graph I/O names, dtypes, and shapes are unchanged. Requires ``isaac_deploy_trt``. Defaults to ``False``. diff --git a/docs/source/generated_configs.rst b/docs/source/generated_configs.rst index dcbd585c..ff163e15 100644 --- a/docs/source/generated_configs.rst +++ b/docs/source/generated_configs.rst @@ -148,7 +148,7 @@ The ``models`` mapping is deterministically ordered. LEAPP guarantees: ``opset_version`` Present on ONNX backends. The ONNX opset used at export. - ``tensorrt_compatible`` + ``optimization`` Present on ONNX backends unless ``backend_params={"annotate_tensorrt_compatible": False}``. ``true`` means every ONNX operator in the exported graph is supported @@ -157,9 +157,16 @@ The ``models`` mapping is deterministically ordered. LEAPP guarantees: also means the installed TensorRT package parsed and built the model. This does **not** switch the runtime ``backend``; Isaac Deploy / Triton still load ``backend: onnx`` unless the deployer maps this flag itself. + Operators that fail the catalog are omitted from the YAML. They are + written to ``log.txt`` as ``tensorrt_blockers : ...``. Catalog ``true`` is not a guarantee that TensorRT can build engines with dynamic shapes or shape-tensor inputs without optimization profiles. + ``tensorrt_version`` + Written next to ``optimization``. ``minimal`` means validation and + optimize used the intersection of every checked-in TensorRT release. + A release such as ``10.16`` means that catalog was selected. + ``pipeline`` ------------ diff --git a/docs/source/guides/debugging.rst b/docs/source/guides/debugging.rst index a08f55e7..dcf1927e 100644 --- a/docs/source/guides/debugging.rst +++ b/docs/source/guides/debugging.rst @@ -184,7 +184,7 @@ TensorRT op-catalog checks, GraphSurgeon optimizations, and DAG merge live in the in-tree ``isaac_deploy_trt`` package (also the ``graph-surgery`` extra), not in the LEAPP tracing CLI. After ``compile_graph()``, optimize exported ONNX in place with ``leapp.optimize_graph(trt_compatible=True)``. That -updates YAML checksums and ``parameters.tensorrt_compatible``. +updates YAML checksums and ``parameters.optimization``. With no ``--tensorrt`` flag, ``check``, ``optimize``, ``optimize-dir``, and ``merge-pipeline --optimize`` use the minimal catalog, @@ -212,7 +212,10 @@ parser table. ``--catalog`` replaces those flags with one JSON file. ``--build`` also runs TensorRT parse/build (requires ``tensorrt``). ``--strict`` exits non-zero if catalog or TensorRT checks fail. -The YAML field ``parameters.tensorrt_compatible`` uses the same minimal -catalog. Set ``backend_params={"annotate_tensorrt_compatible": False}`` to -omit it, or ``{"validate_tensorrt": True, "validate_tensorrt_build": True}`` +The YAML fields ``parameters.optimization`` and ``parameters.tensorrt_version`` +record that check. ``tensorrt_version`` is ``minimal`` when no release was +selected. Operators that fail the catalog are written to ``log.txt`` as +``tensorrt_blockers : ...`` and are not stored in the YAML. +Set ``backend_params={"annotate_tensorrt_compatible": False}`` to omit the +flag, or ``{"validate_tensorrt": True, "validate_tensorrt_build": True}`` to require a TensorRT parse/build before marking ``true``. diff --git a/leapp/backends/onnx_export_backend.py b/leapp/backends/onnx_export_backend.py index 8c5143a8..ed28ce74 100644 --- a/leapp/backends/onnx_export_backend.py +++ b/leapp/backends/onnx_export_backend.py @@ -3,11 +3,30 @@ # SPDX-License-Identifier: Apache-2.0 # +import os import torch from typing import Tuple from leapp.backends.export_backend import ExportBackend, prepare_tensors_for_export, SimplifiedONNXProgram from leapp.utils.logging import _get_logger -import os + + +def log_tensorrt_blockers(onnx_path: str, result) -> None: + """Write TensorRT catalog failures to the LEAPP log, not the YAML.""" + blockers = list(getattr(result, "unsupported_ops", []) or []) + blockers.extend( + f"unknown:{name}" for name in (getattr(result, "unknown_ops", []) or []) + ) + for error in getattr(result, "errors", []) or []: + if str(error).startswith("ONNX ops not "): + continue + blockers.append(str(error)) + if not blockers: + return + _get_logger().warning( + f"tensorrt_blockers {os.path.basename(onnx_path)}: {', '.join(blockers)}" + ) + + import onnx from onnx import AttributeProto, TensorProto, helper from onnx import numpy_helper @@ -22,7 +41,8 @@ def get_backend_metadata(self): metadata['opset_version'] = getattr(self, 'opset_version', _constants.ONNX_DEFAULT_OPSET) tensorrt_compatible = getattr(self, 'tensorrt_compatible', None) if tensorrt_compatible is not None: - metadata['tensorrt_compatible'] = bool(tensorrt_compatible) + metadata['optimization'] = bool(tensorrt_compatible) + metadata['tensorrt_version'] = getattr(self, 'tensorrt_version', None) or "minimal" return metadata def get_backend_model_type(self): @@ -256,7 +276,7 @@ def save(self, save_path: str) -> Tuple[str, str, str]: _get_logger().error( f"ONNX model validation warning (model still saved): {e}") - # Record TensorRT compatibility in YAML (catalog check by default). + # Record the YAML ``optimization`` flag (catalog check by default). # Set backend_params={"annotate_tensorrt_compatible": False} to omit it. # Enable parse/build with {"validate_tensorrt": True} and optional # {"validate_tensorrt_build": True, "validate_tensorrt_strict": True}. @@ -293,8 +313,10 @@ def _annotate_tensorrt_compatible(self, onnx_path: str) -> None: else: result = check_onnx_ops_against_tensorrt(onnx_path) + log_tensorrt_blockers(onnx_path, result) if annotate: self.tensorrt_compatible = bool(result.ok) + self.tensorrt_version = result.tensorrt_version or "minimal" def compile(self, m: torch.nn.Module = None) -> SimplifiedONNXProgram: raise NotImplementedError( diff --git a/leapp/backends/tensorrt_leapp_bundle.py b/leapp/backends/tensorrt_leapp_bundle.py index 260d394d..d3dcd5ab 100644 --- a/leapp/backends/tensorrt_leapp_bundle.py +++ b/leapp/backends/tensorrt_leapp_bundle.py @@ -32,6 +32,7 @@ save_graph, ) from isaac_deploy_trt.validate import check_onnx_ops_against_tensorrt +from leapp.backends.onnx_export_backend import log_tensorrt_blockers from leapp.utils.logging import _get_logger @@ -135,7 +136,7 @@ def _yaml_model_files(export_dir: str) -> Optional[List[str]]: def _update_yaml_parameters( yaml_path: str, hashes_by_filename: Dict[str, tuple[str, str]], - trt_compatible_by_filename: Dict[str, bool], + trt_compatible_by_filename: Dict[str, tuple[bool, str]], ) -> None: with open(yaml_path, "r", encoding="utf-8") as handle: spec = yaml.safe_load(handle) or {} @@ -156,9 +157,20 @@ def _update_yaml_parameters( params["sha256sum"] = sha256sum changed = True if filename in trt_compatible_by_filename: - flag = bool(trt_compatible_by_filename[filename]) - if params.get("tensorrt_compatible") != flag: - params["tensorrt_compatible"] = flag + flag, version = trt_compatible_by_filename[filename] + flag = bool(flag) + version = version or "minimal" + if "tensorrt_compatible" in params: + del params["tensorrt_compatible"] + changed = True + if "tensorrt_blockers" in params: + del params["tensorrt_blockers"] + changed = True + if params.get("optimization") != flag: + params["optimization"] = flag + changed = True + if params.get("tensorrt_version") != version: + params["tensorrt_version"] = version changed = True if not changed: return @@ -200,7 +212,7 @@ def align_leapp_export_for_tensorrt( result = AlignedBundleResult(output_dir=output_dir) hashes: Dict[str, tuple[str, str]] = {} - trt_compatible: Dict[str, bool] = {} + trt_compatible: Dict[str, tuple[bool, str]] = {} surgeon_ops, _catalog = surgeon_ops_for_target() for src in onnx_files: @@ -230,9 +242,9 @@ def align_leapp_export_for_tensorrt( md5sum, sha256sum = _file_hashes(dst) hashes[filename] = (md5sum, sha256sum) - trt_compatible[filename] = bool( - check_onnx_ops_against_tensorrt(dst).ok - ) + catalog = check_onnx_ops_against_tensorrt(dst) + log_tensorrt_blockers(dst, catalog) + trt_compatible[filename] = (bool(catalog.ok), catalog.tensorrt_version or "minimal") result.models.append( AlignedOnnxResult( filename=filename, diff --git a/leapp/leapp.py b/leapp/leapp.py index 905ecf68..79297cb9 100644 --- a/leapp/leapp.py +++ b/leapp/leapp.py @@ -210,7 +210,8 @@ def optimize_graph(trt_compatible=False): When ``trt_compatible=True``, LEAPP optimizes exported ONNX files in the graph output directory so TensorRT can parse them (UINT8 intermediate Casts, Resize ``antialias``, rank-9 Reshape) and updates YAML checksums - plus ``parameters.tensorrt_compatible``. Graph input/output names, dtypes, + plus ``parameters.optimization`` and ``parameters.tensorrt_version``. + Graph input/output names, dtypes, and shapes are left unchanged. Requires ``isaac_deploy_trt``. """ manager = _MANAGER diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/minimal_layers.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/minimal_layers.py new file mode 100644 index 00000000..c7c0b8f1 --- /dev/null +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/minimal_layers.py @@ -0,0 +1,167 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Layers that every checked-in TensorRT catalog marks GPU-supported.""" + +from __future__ import annotations + +import json +from pathlib import Path +from typing import Dict, List + +_CATALOG_ROOT = Path(__file__).resolve().parents[2] / "tensorrt_catalogs" + + +def _release_sort_key(tag: str) -> tuple: + parts = [] + for piece in tag.lstrip("vV").replace("-", ".").split("."): + parts.append(int(piece) if piece.isdigit() else 0) + return tuple(parts) + + +def catalog_layer_files(root: Path | None = None) -> List[Path]: + """Return every platform layer JSON under ``tensorrt_catalogs``.""" + base = root or _CATALOG_ROOT + files = [] + for path in sorted(base.glob("*/tensorrt_layers_*.json")): + files.append(path) + return files + + +def _minimal_onnx_operators(catalogs: list) -> Dict[str, dict]: + """ONNX ops supported only when every catalog marks them supported.""" + maps = [payload.get("onnx_operators") or {} for _path, payload in catalogs] + maps = [ops for ops in maps if ops] + if not maps: + return {} + names = set() + for ops in maps: + names.update(ops) + result: Dict[str, dict] = {} + for name in sorted(names): + infos = [ops.get(name) for ops in maps] + present = [info for info in infos if isinstance(info, dict)] + supported = ( + len(present) == len(maps) + and all(info.get("supported") for info in present) + ) + type_sets = [set(info.get("types") or []) for info in present] + types = sorted(set.intersection(*type_sets)) if type_sets and supported else [] + if supported and any(info.get("types") for info in present) and not types: + supported = False + result[name] = { + "supported": supported, + "types": types if supported else [], + "restrictions": ( + "" + if supported + else "Not supported in every checked-in TensorRT catalog." + ), + } + return result + + +def minimal_catalog_path() -> Path: + """Checked-in minimal catalog used when no TensorRT version is requested.""" + return _CATALOG_ROOT / "minimal" / "tensorrt_layers.json" + + +def minimal_supported_layers(root: Path | None = None) -> Dict[str, object]: + """Intersect native TensorRT layers across every release and platform. + + A layer is included only when every catalog file lists it and sets + ``gpu`` true. Layers added in a later header, or marked unsupported on + JetPack, are listed under ``excluded``. + """ + files = catalog_layer_files(root) + if not files: + raise FileNotFoundError(f"No TensorRT layer catalogs under {root or _CATALOG_ROOT}") + + catalogs = [] + for path in files: + payload = json.loads(path.read_text(encoding="utf-8")) + catalogs.append((path, payload)) + + names = set() + for _path, payload in catalogs: + names.update((payload.get("tensorrt_layers") or {})) + + releases = sorted({ + release + for _path, payload in catalogs + for release in (payload.get("supported_releases") or []) + }, key=_release_sort_key) + platforms = sorted({ + str(payload.get("platform")) + for _path, payload in catalogs + if payload.get("platform") + }) + + layers: Dict[str, Dict[str, object]] = {} + excluded: List[Dict[str, object]] = [] + for name in sorted(names): + missing = [] + gpu_false = [] + for path, payload in catalogs: + table = payload.get("tensorrt_layers") or {} + label = f"{path.parent.name}/{payload.get('platform') or path.stem}" + if name not in table: + missing.append(label) + continue + if not table[name].get("gpu"): + gpu_false.append(label) + if missing or gpu_false: + excluded.append({ + "name": name, + "missing_from": missing, + "gpu_false_on": gpu_false, + }) + continue + layers[name] = { + "gpu": True, + "dla": False, + "notes": "GPU-supported in every checked-in TensorRT catalog.", + } + + return { + "kind": "minimal_supported_layers", + "rule": "gpu=true in every tensorrt_catalogs layer table", + "releases": releases, + "platforms": platforms, + "catalog_count": len(catalogs), + "layer_count": len(layers), + "layers": layers, + "onnx_operators": _minimal_onnx_operators(catalogs), + "excluded": excluded, + "notes": [ + "DLA is not part of this set. x86 and Thor catalogs have no DLA.", + "onnx_operators is the intersection used when no TensorRT version is requested.", + ], + } + + +def format_minimal_layers(report: Dict[str, object]) -> str: + """Render the minimal layer set as plain text.""" + layers = report["layers"] + excluded = report["excluded"] + lines = [ + f"Minimal TensorRT layers: {report['layer_count']}", + f"releases: {', '.join(report['releases'])}", + f"platforms: {', '.join(report['platforms'])}", + f"catalogs: {report['catalog_count']}", + "", + ] + for name in layers: + lines.append(name) + lines.append("") + lines.append(f"Excluded: {len(excluded)}") + for item in excluded: + reason = [] + if item["missing_from"]: + reason.append(f"missing from {len(item['missing_from'])} catalogs") + if item["gpu_false_on"]: + reason.append(f"gpu=false on {len(item['gpu_false_on'])} catalogs") + lines.append(f"{item['name']}: {'; '.join(reason)}") + return "\n".join(lines) diff --git a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py index 323895aa..fe890ef0 100644 --- a/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py +++ b/packages/isaac_deploy_trt/src/isaac_deploy_trt/validate.py @@ -34,6 +34,7 @@ class TensorRTOnnxValidationResult: parse_ok: Optional[bool] = None build_ok: Optional[bool] = None catalog_path: Optional[str] = None + tensorrt_version: Optional[str] = None errors: List[str] = field(default_factory=list) @property @@ -141,6 +142,30 @@ def _catalog_cuda(path: Path) -> str: return "" if cuda is None else str(cuda) +def tensorrt_version_label( + *, + tensorrt: Optional[str] = None, + catalog_path: Optional[str] = None, +) -> str: + """Version string recorded next to the YAML ``optimization`` flag. + + Unspecified checks use the minimal catalog and return ``minimal``. + A requested release is returned without a leading ``v``. + """ + if tensorrt: + text = str(tensorrt).strip() + if text[:1] in "vV" and len(text) > 1 and text[1].isdigit(): + return text[1:] + return text + if catalog_path: + parent = Path(catalog_path).parent.name + if parent == "minimal": + return "minimal" + if parent[:1] in "vV" and len(parent) > 1 and parent[1].isdigit(): + return parent[1:] + return "minimal" + + def _ops_from_catalog_file(path: Path) -> Dict[str, dict]: catalog = json.loads(path.read_text(encoding="utf-8")) operators = catalog.get("onnx_operators") or {} @@ -224,6 +249,10 @@ def check_onnx_ops_against_tensorrt( unsupported_ops=unsupported, unknown_ops=unknown, catalog_path=catalog_path, + tensorrt_version=tensorrt_version_label( + tensorrt=tensorrt, + catalog_path=catalog_path, + ), ) if unsupported: result.errors.append( diff --git a/packages/isaac_deploy_trt/tensorrt_catalogs/minimal/tensorrt_layers.json b/packages/isaac_deploy_trt/tensorrt_catalogs/minimal/tensorrt_layers.json new file mode 100644 index 00000000..2fd24ade --- /dev/null +++ b/packages/isaac_deploy_trt/tensorrt_catalogs/minimal/tensorrt_layers.json @@ -0,0 +1,2186 @@ +{ + "kind": "minimal_supported_layers", + "rule": "gpu=true in every tensorrt_catalogs layer table", + "releases": [ + "v10.7.0", + "v10.8.0", + "v10.9.0", + "v10.10.0", + "v10.11", + "v10.12.0", + "v10.13.0", + "v10.13.2", + "v10.13.3", + "v10.14", + "v10.15", + "v10.16", + "v11.0", + "v11.1", + "v11.2" + ], + "platforms": [ + "dgx", + "orin", + "thor", + "x86" + ], + "catalog_count": 32, + "layer_count": 51, + "layers": { + "ACTIVATION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "ASSERTION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CAST": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CONCATENATION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CONDITION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CONDITIONAL_INPUT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CONDITIONAL_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CONSTANT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "CUMULATIVE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "DECONVOLUTION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "DEQUANTIZE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "EINSUM": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "ELEMENTWISE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "FILL": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "GATHER": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "GRID_SAMPLE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "IDENTITY": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "ITERATOR": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "LOOP": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "LOOP_OUTPUT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "LRN": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "MATRIX_MULTIPLY": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "NMS": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "NON_ZERO": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "NORMALIZATION": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "ONE_HOT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "PADDING": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "PARAMETRIC_RELU": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "PLUGIN": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "PLUGIN_V2": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "PLUGIN_V3": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "POOLING": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "QUANTIZE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "RAGGED_SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "RECURRENCE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "REDUCE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "RESIZE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "REVERSE_SEQUENCE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SCALE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SCATTER": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SELECT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SHAPE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SHUFFLE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SLICE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SOFTMAX": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "SQUEEZE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "TOPK": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "TRIP_LIMIT": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "UNARY": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + }, + "UNSQUEEZE": { + "gpu": true, + "dla": false, + "notes": "GPU-supported in every checked-in TensorRT catalog." + } + }, + "onnx_operators": { + "Abs": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Acos": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Acosh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Add": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "AffineGrid": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "And": { + "supported": true, + "types": [ + "BOOL" + ], + "restrictions": "" + }, + "ArgMax": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ArgMin": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Asin": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Asinh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Atan": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Atanh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Attention": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT8" + ], + "restrictions": "" + }, + "AveragePool": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "BatchNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Bernoulli": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "BitShift": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "BitwiseAnd": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "BitwiseNot": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "BitwiseOr": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "BitwiseXor": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "BlackmanWindow": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Cast": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64", + "UINT8" + ], + "restrictions": "" + }, + "CastLike": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64", + "UINT8" + ], + "restrictions": "" + }, + "Ceil": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Celu": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "CenterCropPad": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Clip": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Col2Im": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Compress": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Concat": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ConcatFromSequence": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Constant": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ConstantOfShape": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Conv": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "ConvInteger": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "ConvTranspose": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Cos": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Cosh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "CumSum": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "DFT": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "DeformConv": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "DepthToSpace": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "DequantizeLinear": { + "supported": true, + "types": [ + "INT8" + ], + "restrictions": "" + }, + "Det": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Div": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Dropout": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "DynamicQuantizeLinear": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Einsum": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Elu": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Equal": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Erf": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Exp": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Expand": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "EyeLike": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Flatten": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Floor": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "GRU": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Gather": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "GatherElements": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "GatherND": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Gelu": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64", + "INT8" + ], + "restrictions": "" + }, + "Gemm": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "GlobalAveragePool": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "GlobalLpPool": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "GlobalMaxPool": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Greater": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "GreaterOrEqual": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "GridSample": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "GroupNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "HammingWindow": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "HannWindow": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "HardSigmoid": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "HardSwish": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Hardmax": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Identity": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "If": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ImageDecoder": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "ImageScaler": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "InstanceNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "IsInf": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "IsNaN": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "LRN": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "LSTM": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "LayerNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "LeakyRelu": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Less": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "LessOrEqual": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Log": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "LogSoftmax": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Loop": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "LpNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "LpPool": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "MatMul": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "MatMulInteger": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Max": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "MaxPool": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "MaxRoiPool": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "MaxUnpool": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Mean": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "MeanVarianceNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "MelWeightMatrix": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Min": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Mish": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Mod": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Mul": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Multinomial": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Neg": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "NegativeLogLikelihoodLoss": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "NonMaxSuppression": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "NonZero": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Not": { + "supported": true, + "types": [ + "BOOL" + ], + "restrictions": "" + }, + "OneHot": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Optional": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "OptionalGetElement": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "OptionalHasElement": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Or": { + "supported": true, + "types": [ + "BOOL" + ], + "restrictions": "" + }, + "PRelu": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Pad": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ParametricSoftplus": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Pow": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "QLinearConv": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "QLinearMatMul": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "QuantizeLinear": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RMSNormalization": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RNN": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RandomNormal": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RandomNormalLike": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RandomUniform": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RandomUniformLike": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Range": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Reciprocal": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "ReduceL1": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceL2": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceLogSum": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceLogSumExp": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceMax": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceMean": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceMin": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceProd": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceSum": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ReduceSumSquare": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "RegexFullMatch": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Relu": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Reshape": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Resize": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "ReverseSequence": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "RoiAlign": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "RotaryEmbedding": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Round": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "STFT": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "ScaledTanh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Scan": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Scatter": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ScatterElements": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "ScatterND": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Selu": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "SequenceAt": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "SequenceConstruct": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "SequenceEmpty": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "SequenceErase": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "SequenceInsert": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "SequenceLength": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "SequenceMap": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Shape": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Shrink": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Sigmoid": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Sign": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Sin": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Sinh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Size": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Slice": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Softmax": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "SoftmaxCrossEntropyLoss": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Softplus": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Softsign": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "SpaceToDepth": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Split": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "SplitToSequence": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Sqrt": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Squeeze": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "StringConcat": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "StringNormalizer": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "StringSplit": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Sub": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Sum": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Swish": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Tan": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Tanh": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "TensorScatter": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32" + ], + "restrictions": "" + }, + "TfIdfVectorizer": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "ThresholdedRelu": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Tile": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "TopK": { + "supported": true, + "types": [ + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Transpose": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Trilu": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Unique": { + "supported": false, + "types": [], + "restrictions": "Not supported in every checked-in TensorRT catalog." + }, + "Unsqueeze": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Upsample": { + "supported": true, + "types": [ + "FP16", + "FP32" + ], + "restrictions": "" + }, + "Where": { + "supported": true, + "types": [ + "BOOL", + "FP16", + "FP32", + "INT32", + "INT64" + ], + "restrictions": "" + }, + "Xor": { + "supported": true, + "types": [ + "BOOL" + ], + "restrictions": "" + } + }, + "excluded": [ + { + "name": "ATTENTION", + "missing_from": [], + "gpu_false_on": [ + "v10.11/orin", + "v10.11/thor", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.14/orin", + "v10.14/thor", + "v10.15/orin", + "v10.15/thor", + "v10.16/orin", + "v10.16/thor", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.8.0/orin", + "v10.8.0/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "ATTENTION_INPUT", + "missing_from": [ + "v10.11/dgx", + "v10.11/orin", + "v10.11/thor", + "v10.11/x86", + "v10.13.3/dgx", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.13.3/x86", + "v10.7.0/dgx", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.7.0/x86", + "v10.8.0/dgx", + "v10.8.0/orin", + "v10.8.0/thor", + "v10.8.0/x86" + ], + "gpu_false_on": [ + "v10.14/orin", + "v10.14/thor", + "v10.15/orin", + "v10.15/thor", + "v10.16/orin", + "v10.16/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "ATTENTION_OUTPUT", + "missing_from": [ + "v10.11/dgx", + "v10.11/orin", + "v10.11/thor", + "v10.11/x86", + "v10.13.3/dgx", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.13.3/x86", + "v10.7.0/dgx", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.7.0/x86", + "v10.8.0/dgx", + "v10.8.0/orin", + "v10.8.0/thor", + "v10.8.0/x86" + ], + "gpu_false_on": [ + "v10.14/orin", + "v10.14/thor", + "v10.15/orin", + "v10.15/thor", + "v10.16/orin", + "v10.16/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "DIST_COLLECTIVE", + "missing_from": [ + "v10.11/dgx", + "v10.11/orin", + "v10.11/thor", + "v10.11/x86", + "v10.13.3/dgx", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.13.3/x86", + "v10.14/dgx", + "v10.14/orin", + "v10.14/thor", + "v10.14/x86", + "v10.15/dgx", + "v10.15/orin", + "v10.15/thor", + "v10.15/x86", + "v10.7.0/dgx", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.7.0/x86", + "v10.8.0/dgx", + "v10.8.0/orin", + "v10.8.0/thor", + "v10.8.0/x86" + ], + "gpu_false_on": [ + "v10.16/orin", + "v10.16/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "DYNAMIC_QUANTIZE", + "missing_from": [], + "gpu_false_on": [ + "v10.11/orin", + "v10.11/thor", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.14/orin", + "v10.14/thor", + "v10.15/orin", + "v10.15/thor", + "v10.16/orin", + "v10.16/thor", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.8.0/orin", + "v10.8.0/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "KVCACHE_UPDATE", + "missing_from": [ + "v10.11/dgx", + "v10.11/orin", + "v10.11/thor", + "v10.11/x86", + "v10.13.3/dgx", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.13.3/x86", + "v10.14/dgx", + "v10.14/orin", + "v10.14/thor", + "v10.14/x86", + "v10.7.0/dgx", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.7.0/x86", + "v10.8.0/dgx", + "v10.8.0/orin", + "v10.8.0/thor", + "v10.8.0/x86" + ], + "gpu_false_on": [ + "v10.15/orin", + "v10.15/thor", + "v10.16/orin", + "v10.16/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "MOE", + "missing_from": [ + "v10.11/dgx", + "v10.11/orin", + "v10.11/thor", + "v10.11/x86", + "v10.13.3/dgx", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.13.3/x86", + "v10.14/dgx", + "v10.14/orin", + "v10.14/thor", + "v10.14/x86", + "v10.15/dgx", + "v10.15/orin", + "v10.15/thor", + "v10.15/x86", + "v10.7.0/dgx", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.7.0/x86", + "v10.8.0/dgx", + "v10.8.0/orin", + "v10.8.0/thor", + "v10.8.0/x86" + ], + "gpu_false_on": [ + "v10.16/orin", + "v10.16/thor", + "v11.2/orin", + "v11.2/thor" + ] + }, + { + "name": "ROTARY_EMBEDDING", + "missing_from": [ + "v10.11/dgx", + "v10.11/orin", + "v10.11/thor", + "v10.11/x86", + "v10.13.3/dgx", + "v10.13.3/orin", + "v10.13.3/thor", + "v10.13.3/x86", + "v10.14/dgx", + "v10.14/orin", + "v10.14/thor", + "v10.14/x86", + "v10.7.0/dgx", + "v10.7.0/orin", + "v10.7.0/thor", + "v10.7.0/x86", + "v10.8.0/dgx", + "v10.8.0/orin", + "v10.8.0/thor", + "v10.8.0/x86" + ], + "gpu_false_on": [ + "v10.15/orin", + "v10.15/thor", + "v10.16/orin", + "v10.16/thor", + "v11.2/orin", + "v11.2/thor" + ] + } + ], + "notes": [ + "DLA is not part of this set. x86 and Thor catalogs have no DLA.", + "onnx_operators is the intersection used when no TensorRT version is requested." + ] +} diff --git a/packages/isaac_deploy_trt/tests/test_check_version.py b/packages/isaac_deploy_trt/tests/test_check_version.py new file mode 100644 index 00000000..3e586262 --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_check_version.py @@ -0,0 +1,131 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for selecting a TensorRT release in ``isaac_deploy_trt check``.""" + +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +import onnx +from onnx import TensorProto, helper + +from isaac_deploy_trt.cli import main +from isaac_deploy_trt.prepare import surgeon_ops_for_target +from isaac_deploy_trt.tensorrt_onnx_ops import SURGEON_UNSUPPORTED_OPS +from isaac_deploy_trt.validate import ( + check_onnx_ops_against_tensorrt, + resolve_tensorrt_catalog, +) + + +def _write_model(path: Path, op_type: str) -> None: + node = helper.make_node(op_type, inputs=["x"], outputs=["y"]) + value = helper.make_tensor_value_info("x", TensorProto.FLOAT, [1]) + output = helper.make_tensor_value_info("y", TensorProto.FLOAT, [1]) + graph = helper.make_graph([node], "g", [value], [output]) + model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 17)]) + onnx.save(model, path) + + +class CheckTensorRTVersionTests(unittest.TestCase): + def test_resolve_10_16_orin_catalog(self): + path = resolve_tensorrt_catalog("10.16", platform="orin") + self.assertEqual(path.parent.name, "v10.16") + self.assertIn("orin", path.name) + self.assertEqual( + resolve_tensorrt_catalog("v10.16.1", platform="orin"), + path, + ) + + def test_check_uses_10_16_catalog(self): + with tempfile.TemporaryDirectory() as tmp: + model = Path(tmp) / "add.onnx" + _write_model(model, "Add") + result = check_onnx_ops_against_tensorrt( + str(model), tensorrt="10.16", platform="orin" + ) + default = check_onnx_ops_against_tensorrt(str(model)) + platform_only = check_onnx_ops_against_tensorrt(str(model), platform="orin") + self.assertTrue(result.ok) + self.assertIn("/v10.16/", result.catalog_path.replace("\\", "/")) + self.assertIn("minimal/tensorrt_layers.json", default.catalog_path.replace("\\", "/")) + self.assertEqual(default.tensorrt_version, "minimal") + self.assertEqual(result.tensorrt_version, "10.16") + self.assertTrue(default.ok) + self.assertIn( + "minimal/tensorrt_layers.json", + platform_only.catalog_path.replace("\\", "/"), + ) + + def test_unknown_release_is_rejected(self): + with self.assertRaises(KeyError): + resolve_tensorrt_catalog("9.9") + + def test_cli_check_tensorrt_flag(self): + with tempfile.TemporaryDirectory() as tmp: + model = Path(tmp) / "add.onnx" + _write_model(model, "Add") + code = main([ + "check", + "--onnx", + str(model), + "--tensorrt", + "10.16", + "--platform", + "orin", + "--strict", + ]) + unknown = main([ + "check", + "--onnx", + str(model), + "--tensorrt", + "9.9", + ]) + self.assertEqual(code, 0) + self.assertEqual(unknown, 2) + + def test_default_rewrite_uses_minimal_catalog(self): + ops, catalog = surgeon_ops_for_target() + self.assertIn("minimal/tensorrt_layers.json", catalog.replace("\\", "/")) + self.assertTrue(set(ops) <= SURGEON_UNSUPPORTED_OPS) + + def test_rewrite_uses_10_16_catalog(self): + ops, catalog = surgeon_ops_for_target(tensorrt="10.16", platform="orin") + self.assertIsNotNone(catalog) + self.assertIn("v10.16", catalog) + self.assertTrue(set(ops) <= SURGEON_UNSUPPORTED_OPS) + with tempfile.TemporaryDirectory() as tmp: + model = Path(tmp) / "add.onnx" + out = Path(tmp) / "add_trt.onnx" + _write_model(model, "Add") + code = main([ + "optimize", + str(model), + "-o", + str(out), + "--tensorrt", + "10.16", + "--platform", + "orin", + ]) + unknown = main([ + "optimize", + str(model), + "-o", + str(Path(tmp) / "bad.onnx"), + "--tensorrt", + "9.9", + ]) + self.assertEqual(code, 0) + self.assertTrue(out.is_file()) + self.assertEqual(unknown, 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/packages/isaac_deploy_trt/tests/test_minimal_layers.py b/packages/isaac_deploy_trt/tests/test_minimal_layers.py new file mode 100644 index 00000000..859d441d --- /dev/null +++ b/packages/isaac_deploy_trt/tests/test_minimal_layers.py @@ -0,0 +1,60 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# + +"""Tests for the intersection of checked-in TensorRT layer catalogs.""" + +from __future__ import annotations + +import json +import unittest +from pathlib import Path + +from isaac_deploy_trt.cli import main +from isaac_deploy_trt.minimal_layers import minimal_supported_layers + +_CHECKED_IN = ( + Path(__file__).resolve().parents[1] + / "tensorrt_catalogs" + / "minimal" + / "tensorrt_layers.json" +) + + +class MinimalLayersTests(unittest.TestCase): + def test_intersection_drops_newer_and_jetpack_layers(self): + report = minimal_supported_layers() + names = set(report["layers"]) + excluded = {item["name"] for item in report["excluded"]} + self.assertIn("CONVOLUTION", names) + self.assertNotIn("ATTENTION", names) + self.assertIn("ATTENTION", excluded) + self.assertIn("MOE", excluded) + self.assertGreater(report["layer_count"], 0) + self.assertEqual(report["layer_count"], len(names)) + + def test_checked_in_catalog_matches_intersection(self): + report = minimal_supported_layers() + checked = json.loads(_CHECKED_IN.read_text(encoding="utf-8")) + self.assertEqual(checked["layers"], report["layers"]) + self.assertEqual(checked["onnx_operators"], report["onnx_operators"]) + self.assertEqual( + [item["name"] for item in checked["excluded"]], + [item["name"] for item in report["excluded"]], + ) + + def test_cli_writes_json(self): + import tempfile + + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / "minimal.json" + code = main(["minimal-layers", "-o", str(path)]) + payload = json.loads(path.read_text(encoding="utf-8")) + self.assertEqual(code, 0) + self.assertEqual(payload["kind"], "minimal_supported_layers") + self.assertIn("CONVOLUTION", payload["layers"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/unit_tests/test_tensorrt_leapp_bundle.py b/tests/unit_tests/test_tensorrt_leapp_bundle.py index f277f68a..6a8d143f 100644 --- a/tests/unit_tests/test_tensorrt_leapp_bundle.py +++ b/tests/unit_tests/test_tensorrt_leapp_bundle.py @@ -27,6 +27,7 @@ rewrite_leapp_export_for_tensorrt = None # type: ignore[assignment] from leapp.backends.onnx_export_backend import ONNXExportBackend +from leapp.utils.logging import _get_logger def _write_abs_onnx(path: str) -> None: @@ -145,11 +146,17 @@ def test_aligns_filenames_io_and_yaml_checksums(self): out_spec["models"]["backbone"]["parameters"]["backend"], "onnx" ) self.assertTrue( - out_spec["models"]["backbone"]["parameters"]["tensorrt_compatible"] + out_spec["models"]["backbone"]["parameters"]["optimization"] ) self.assertTrue( - video_params["tensorrt_compatible"] + video_params["optimization"] ) + self.assertEqual(video_params["tensorrt_version"], "minimal") + self.assertEqual( + out_spec["models"]["backbone"]["parameters"]["tensorrt_version"], + "minimal", + ) + self.assertNotIn("tensorrt_compatible", video_params) def test_yaml_marks_unsupported_ops_not_tensorrt_compatible(self): with tempfile.TemporaryDirectory() as tmp: @@ -177,7 +184,11 @@ def test_yaml_marks_unsupported_ops_not_tensorrt_compatible(self): with open(os.path.join(dst, "exported_leapp.yaml"), encoding="utf-8") as handle: out_spec = yaml.safe_load(handle) self.assertFalse( - out_spec["models"]["head"]["parameters"]["tensorrt_compatible"] + out_spec["models"]["head"]["parameters"]["optimization"] + ) + self.assertEqual( + out_spec["models"]["head"]["parameters"]["tensorrt_version"], + "minimal", ) def test_rewrite_leapp_export_for_tensorrt_inplace(self): @@ -230,19 +241,29 @@ def test_onnx_export_backend_annotates_tensorrt_compatible(self): backend.backend_params = {} backend._annotate_tensorrt_compatible(onnx_path) self.assertTrue(backend.tensorrt_compatible) - self.assertTrue(backend.get_backend_metadata()["tensorrt_compatible"]) + self.assertTrue(backend.get_backend_metadata()["optimization"]) + self.assertEqual(backend.get_backend_metadata()["tensorrt_version"], "minimal") det_path = os.path.join(tmp, "det.onnx") _write_det_onnx(det_path) backend.tensorrt_compatible = None + log_dir = os.path.join(tmp, "logs") + os.makedirs(log_dir) + _get_logger().configure(log_dir, verbose=False) backend._annotate_tensorrt_compatible(det_path) self.assertFalse(backend.tensorrt_compatible) + self.assertNotIn("tensorrt_blockers", backend.get_backend_metadata()) + for handler in _get_logger().logger.handlers: + handler.flush() + with open(os.path.join(log_dir, "log.txt"), encoding="utf-8") as handle: + log_text = handle.read() + self.assertIn("tensorrt_blockers det.onnx: Det", log_text) backend.backend_params = {"annotate_tensorrt_compatible": False} backend.tensorrt_compatible = None backend._annotate_tensorrt_compatible(onnx_path) self.assertIsNone(getattr(backend, "tensorrt_compatible", None)) - self.assertNotIn("tensorrt_compatible", backend.get_backend_metadata()) + self.assertNotIn("optimization", backend.get_backend_metadata()) if __name__ == "__main__":