From 84dd6ed18c2ec7a2d8a199ec1a437d09284d86bd Mon Sep 17 00:00:00 2001 From: Balarama Raju Buddharaju Date: Wed, 7 Aug 2024 12:11:46 -0700 Subject: [PATCH] Updates for Release 10.3-GA. Signed-off-by: Balarama Raju Buddharaju --- .clang-format | 2 +- CHANGELOG.md | 18 +- LICENSE | 21 +- README.md | 18 +- VERSION | 2 +- demo/BERT/README.md | 2 +- demo/Diffusion/README.md | 26 +- demo/Diffusion/demo_img2vid.py | 117 ++++ demo/Diffusion/models.py | 389 +++++++++-- demo/Diffusion/requirements.txt | 2 +- demo/Diffusion/stable_diffusion_3_pipeline.py | 18 +- demo/Diffusion/stable_diffusion_pipeline.py | 23 +- .../stable_video_diffusion_pipeline.py | 641 ++++++++++++++++++ demo/Diffusion/utilities.py | 170 ++++- demo/Diffusion/utils_sd3/mmdit.py | 1 - docker/rockylinux8.Dockerfile | 18 +- docker/rockylinux9.Dockerfile | 18 +- docker/ubuntu-20.04.Dockerfile | 18 +- docker/ubuntu-22.04-aarch64.Dockerfile | 2 +- docker/ubuntu-22.04.Dockerfile | 18 +- docker/ubuntu-cross-aarch64.Dockerfile | 2 +- include/NvInfer.h | 85 ++- include/NvInferImpl.h | 3 + include/NvInferRuntime.h | 57 ++ include/NvInferVersion.h | 6 +- parsers/onnx | 2 +- plugin/README.md | 6 +- plugin/api/inferPlugin.cpp | 4 +- plugin/gridAnchorPlugin/README.md | 2 +- plugin/instanceNormalizationPlugin/README.md | 2 +- .../multiscaleDeformableAttnPlugin/README.md | 2 +- plugin/nvFasterRCNN/README.md | 2 +- plugin/priorBoxPlugin/README.md | 2 +- plugin/scatterElementsPlugin/README.md | 14 +- .../ScatterElementsPlugin_PluginConfig.yaml | 16 +- .../scatterElementsCommon.h | 41 ++ .../scatterElementsPlugin.cpp | 243 ++++--- .../scatterElementsPlugin.h | 119 ++-- .../scatterElementsPluginKernel.h | 1 + .../scatterElementsPluginLegacy.cpp | 316 +++++++++ .../scatterElementsPluginLegacy.h | 123 ++++ python/CMakeLists.txt | 6 + python/docstrings/infer/pyCoreDoc.h | 6 +- python/docstrings/infer/pyGraphDoc.h | 27 +- python/docstrings/infer/pyPluginDoc.h | 33 + .../bindings_wheel/tensorrt/__init__.py | 1 - python/src/infer/pyCore.cpp | 12 +- python/src/infer/pyGraph.cpp | 5 +- python/src/infer/pyPlugin.cpp | 113 ++- quickstart/Makefile.config | 5 +- .../SemanticSegmentation/tutorial-runtime.cpp | 47 +- .../tutorial-runtime.ipynb | 136 +++- quickstart/common/logging.h | 2 +- quickstart/common/util.h | 15 - requirements.txt | 2 +- samples/common/sampleEngines.cpp | 28 +- samples/common/sampleOptions.cpp | 12 +- samples/common/sampleOptions.h | 1 + samples/python/detectron2/requirements.txt | 3 +- samples/python/downloader.py | 32 +- samples/python/efficientdet/requirements.txt | 6 +- samples/python/efficientnet/requirements.txt | 3 +- .../python/non_zero_plugin/requirements.txt | 6 +- samples/python/python_plugin/requirements.txt | 6 +- .../tensorflow_object_detection_api/README.md | 2 + .../requirements.txt | 8 +- samples/sampleDynamicReshape/README.md | 2 +- samples/sampleINT8API/README.md | 19 +- scripts/stubify.sh | 2 + tools/Polygraphy/CHANGELOG.md | 5 + .../05_inspecting_inference_outputs/README.md | 2 +- .../06_inspecting_input_data/README.md | 2 +- .../extension_module/setup.py | 1 + tools/Polygraphy/polygraphy/README.md | 11 + tools/Polygraphy/polygraphy/__init__.py | 2 +- .../Polygraphy/polygraphy/comparator/util.py | 8 +- tools/Polygraphy/polygraphy/datatype/numpy.py | 2 +- tools/Polygraphy/polygraphy/logger/logger.py | 28 +- tools/Polygraphy/tests/conftest.py | 18 + tools/Polygraphy/tests/logger/test_logger.py | 43 ++ 80 files changed, 2701 insertions(+), 533 deletions(-) mode change 100644 => 100755 demo/Diffusion/README.md create mode 100644 demo/Diffusion/demo_img2vid.py mode change 100644 => 100755 demo/Diffusion/requirements.txt mode change 100755 => 100644 demo/Diffusion/stable_diffusion_pipeline.py create mode 100644 demo/Diffusion/stable_video_diffusion_pipeline.py create mode 100644 plugin/scatterElementsPlugin/scatterElementsCommon.h create mode 100644 plugin/scatterElementsPlugin/scatterElementsPluginLegacy.cpp create mode 100644 plugin/scatterElementsPlugin/scatterElementsPluginLegacy.h diff --git a/.clang-format b/.clang-format index da4c3928a..4e34c05e2 100644 --- a/.clang-format +++ b/.clang-format @@ -74,7 +74,7 @@ SpacesInContainerLiterals: true SpacesInParentheses: false SpacesInSquareBrackets: false Standard: Cpp11 -StatementMacros: [API_ENTRY_TRY] +StatementMacros: [API_ENTRY_TRY,TRT_TRY] TabWidth: 4 UseTab: Never ... diff --git a/CHANGELOG.md b/CHANGELOG.md index ebb29fa9f..a67bb266c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,22 @@ # TensorRT OSS Release Changelog -## 10.2.0 GA - 2024-07-10 +## 10.3.0 GA - 2024-08-07 + +Key Features and Updates: + + - Demo changes + - Added [Stable Video Diffusion](demo/Diffusion)(`SVD`) pipeline. + - Plugin changes + - Deprecated Version 1 of [ScatterElements plugin](plugin/scatterElementsPlugin). It is superseded by Version 2, which implements the `IPluginV3` interface. + - Quickstart guide + - Updated the [SemanticSegmentation](quickstart/SemanticSegmentation) guide with latest APIs. + - Parser changes + - Added support for tensor `axes` inputs for `Slice` node. + - Updated `ScatterElements` importer to use Version 2 of [ScatterElements plugin](plugin/scatterElementsPlugin), which implements the `IPluginV3` interface. + - Updated tooling + - Polygraphy v0.49.13 + +## 10.2.0 GA - 2024-07-09 Key Features and Updates: diff --git a/LICENSE b/LICENSE index e80db763a..1ac1dc1f8 100644 --- a/LICENSE +++ b/LICENSE @@ -337,10 +337,11 @@ limitations under the License. > demo/Diffusion/utilities.py + > demo/Diffusion/stable_video_diffusion_pipeline.py HuggingFace diffusers library. - Copyright 2022 The HuggingFace Team. + Copyright 2024 The HuggingFace Team. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -380,3 +381,21 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + > demo/Diffusion/utilities.py + + ModelScope library. + + Copyright (c) Alibaba, Inc. and its affiliates. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index 991048b96..4a120aabd 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ You can skip the **Build** section to enjoy TensorRT with Python. To build the TensorRT-OSS components, you will first need the following software packages. **TensorRT GA build** -* TensorRT v10.2.0.19 +* TensorRT v10.3.0.26 * Available from direct download links listed below **System Packages** @@ -73,25 +73,25 @@ To build the TensorRT-OSS components, you will first need the following software If using the TensorRT OSS build container, TensorRT libraries are preinstalled under `/usr/lib/x86_64-linux-gnu` and you may skip this step. Else download and extract the TensorRT GA build from [NVIDIA Developer Zone](https://developer.nvidia.com) with the direct links below: - - [TensorRT 10.2.0.19 for CUDA 11.8, Linux x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz) - - [TensorRT 10.2.0.19 for CUDA 12.5, Linux x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz) - - [TensorRT 10.2.0.19 for CUDA 11.8, Windows x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/zip/TensorRT-10.2.0.19.Windows.win10.cuda-11.8.zip) - - [TensorRT 10.2.0.19 for CUDA 12.5, Windows x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/zip/TensorRT-10.2.0.19.Windows.win10.cuda-12.5.zip) + - [TensorRT 10.3.0.26 for CUDA 11.8, Linux x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz) + - [TensorRT 10.3.0.26 for CUDA 12.5, Linux x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz) + - [TensorRT 10.3.0.26 for CUDA 11.8, Windows x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/zip/TensorRT-10.3.0.26.Windows.win10.cuda-11.8.zip) + - [TensorRT 10.3.0.26 for CUDA 12.5, Windows x86_64](https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/zip/TensorRT-10.3.0.26.Windows.win10.cuda-12.5.zip) **Example: Ubuntu 20.04 on x86-64 with cuda-12.5** ```bash cd ~/Downloads - tar -xvzf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz - export TRT_LIBPATH=`pwd`/TensorRT-10.2.0.19 + tar -xvzf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz + export TRT_LIBPATH=`pwd`/TensorRT-10.3.0.26 ``` **Example: Windows on x86-64 with cuda-12.5** ```powershell - Expand-Archive -Path TensorRT-10.2.0.19.Windows.win10.cuda-12.5.zip - $env:TRT_LIBPATH="$pwd\TensorRT-10.2.0.19\lib" + Expand-Archive -Path TensorRT-10.3.0.26.Windows.win10.cuda-12.5.zip + $env:TRT_LIBPATH="$pwd\TensorRT-10.3.0.26\lib" ``` ## Setting Up The Build Environment diff --git a/VERSION b/VERSION index 0afb8eb4b..92bc5b535 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -10.2.0.19 +10.3.0.26 diff --git a/demo/BERT/README.md b/demo/BERT/README.md index 68cc327ce..b48bd8be5 100755 --- a/demo/BERT/README.md +++ b/demo/BERT/README.md @@ -75,7 +75,7 @@ The following software version configuration has been tested: |Software|Version| |--------|-------| |Python|>=3.8| -|TensorRT|10.2.0.19| +|TensorRT|10.3.0.26| |CUDA|12.5| ## Setup diff --git a/demo/Diffusion/README.md b/demo/Diffusion/README.md old mode 100644 new mode 100755 index 5016a12e3..469f0b268 --- a/demo/Diffusion/README.md +++ b/demo/Diffusion/README.md @@ -48,14 +48,14 @@ onnx 1.15.0 onnx-graphsurgeon 0.5.2 onnxruntime 1.16.3 polygraphy 0.49.9 -tensorrt 10.2.0.19 +tensorrt 10.3.0.26 tokenizers 0.13.3 torch 2.2.0 transformers 4.33.1 controlnet-aux 0.0.6 nvidia-modelopt 0.11.2 ``` -> NOTE: optionally install HuggingFace [accelerate](https://pypi.org/project/accelerate/) package for faster and less memory-intense model loading. +> NOTE: optionally install HuggingFace [accelerate](https://pypi.org/project/accelerate/) package for faster and less memory-intense model loading. Note that installing accelerate is known to cause failures while running certain pipelines in Torch Compile mode ([known issue](https://github.com/huggingface/diffusers/issues/9091)) # Running demoDiffusion @@ -178,6 +178,28 @@ python3 demo_txt2img_sd3.py "dog wearing a sweater and a blue collar" --version Note that a denosing-percentage is applied to the number of denoising-steps when an input image conditioning is provided. Its default value is set to 0.6. This parameter can be updated using `--denoising-percentage` +### Image-to-video using SVD (Stable Video Diffusion) + +Download the pre-exported ONNX model + +```bash +git lfs install +git clone https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt-1-1-tensorrt onnx-svd-xt-1-1 +cd onnx-svd-xt-1-1 && git lfs pull && cd .. +``` + +SVD-XT-1.1 (25 frames at resolution 576x1024) +```bash +python3 demo_img2vid.py --version svd-xt-1.1 --onnx-dir onnx-svd-xt-1-1 --engine-dir engine-svd-xt-1-1 --hf-token=$HF_TOKEN +``` + +You may also specify a custom conditioning image using `--input-image`: +```bash +python3 demo_img2vid.py --version svd-xt-1.1 --onnx-dir onnx-svd-xt-1-1 --engine-dir engine-svd-xt-1-1 --input-image https://www.hdcarwallpapers.com/walls/2018_chevrolet_camaro_zl1_nascar_race_car_2-HD.jpg --hf-token=$HF_TOKEN +``` + +NOTE: The min and max guidance scales are configured using --min-guidance-scale and --max-guidance-scale respectively. + ## Configuration options - Noise scheduler can be set using `--scheduler `. Note: not all schedulers are available for every version. - To accelerate engine building time use `--timing-cache `. The cache file will be created if it does not already exist. Note that performance may degrade if cache files are used across multiple GPU targets. It is recommended to use timing caches only during development. To achieve the best perfromance in deployment, please build engines without timing cache. diff --git a/demo/Diffusion/demo_img2vid.py b/demo/Diffusion/demo_img2vid.py new file mode 100644 index 000000000..7d7b2b048 --- /dev/null +++ b/demo/Diffusion/demo_img2vid.py @@ -0,0 +1,117 @@ +# +# SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import argparse + +from PIL import Image + +from stable_video_diffusion_pipeline import StableVideoDiffusionPipeline +from utilities import ( + PIPELINE_TYPE, + add_arguments, + download_image, +) + +def parseArgs(): + parser = argparse.ArgumentParser(description="Options for Stable Diffusion Img2Vid Demo", conflict_handler='resolve') + parser = add_arguments(parser) + parser.add_argument('--version', type=str, default="svd-xt-1.1", choices=["svd-xt-1.1"], help="Version of Stable Video Diffusion") + parser.add_argument('--input-image', type=str, default="", help="Path to the input image") + parser.add_argument('--height', type=int, default=576, help="Height of image to generate (must be multiple of 8)") + parser.add_argument('--width', type=int, default=1024, help="Width of image to generate (must be multiple of 8)") + parser.add_argument('--min-guidance-scale', type=float, default=1.0, help="The minimum guidance scale. Used for the classifier free guidance with first frame") + parser.add_argument('--max-guidance-scale', type=float, default=3.0, help="The maximum guidance scale. Used for the classifier free guidance with last frame") + parser.add_argument('--denoising-steps', type=int, default=25, help="Number of denoising steps") + parser.add_argument('--num-warmup-runs', type=int, default=1, help="Number of warmup runs before benchmarking performance") + return parser.parse_args() + +def process_pipeline_args(args): + + if not args.input_image: + args.input_image = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/svd/rocket.png?download=true" + if isinstance(args.input_image, str): + input_image = download_image(args.input_image).resize((args.width, args.height)) + elif isinstance(args.input_image, Image.Image): + input_image = Image.open(args.input_image) + else: + raise ValueError(f"Input image(s) must be of type `PIL.Image.Image` or `str` (URL) but is {type(args.input_image)}") + + if args.height % 8 != 0 or args.width % 8 != 0: + raise ValueError(f"Image height and width have to be divisible by 8 but are: {args.image_height} and {args.width}.") + + # TODO enable BS>1 + max_batch_size = 1 + args.build_static_batch = True + + if args.batch_size > max_batch_size: + raise ValueError(f"Batch size {args.batch_size} is larger than allowed {max_batch_size}.") + + if not args.build_static_batch or args.build_dynamic_shape: + raise ValueError(f"Dynamic shapes not supported. Do not specify `--build-dynamic-shape`") + + kwargs_init_pipeline = { + 'version': args.version, + 'max_batch_size': max_batch_size, + 'denoising_steps': args.denoising_steps, + 'scheduler': args.scheduler, + 'min_guidance_scale': args.min_guidance_scale, + 'max_guidance_scale': args.max_guidance_scale, + 'output_dir': args.output_dir, + 'hf_token': args.hf_token, + 'verbose': args.verbose, + 'nvtx_profile': args.nvtx_profile, + 'use_cuda_graph': args.use_cuda_graph, + 'framework_model_dir': args.framework_model_dir, + 'torch_inference': args.torch_inference, + } + + kwargs_load_engine = { + 'onnx_opset': args.onnx_opset, + 'opt_batch_size': args.batch_size, + 'opt_image_height': args.height, + 'opt_image_width': args.width, + 'static_batch': args.build_static_batch, + 'static_shape': not args.build_dynamic_shape, + 'enable_all_tactics': args.build_all_tactics, + 'enable_refit': args.build_enable_refit, + 'timing_cache': args.timing_cache, + } + + args_run_demo = (input_image, args.height, args.width, args.batch_size, args.batch_count, args.num_warmup_runs, args.use_cuda_graph) + + return kwargs_init_pipeline, kwargs_load_engine, args_run_demo + +if __name__ == "__main__": + print("[I] Initializing StableDiffusion img2vid demo using TensorRT") + args = parseArgs() + kwargs_init_pipeline, kwargs_load_engine, args_run_demo = process_pipeline_args(args) + + # Initialize demo + demo = StableVideoDiffusionPipeline( + pipeline_type=PIPELINE_TYPE.IMG2VID, + **kwargs_init_pipeline) + demo.loadEngines( + args.engine_dir, + args.framework_model_dir, + args.onnx_dir, + **kwargs_load_engine) + demo.loadResources(args.height, args.width, args.batch_size, args.seed) + + # Run inference + demo.run(*args_run_demo) + + demo.teardown() diff --git a/demo/Diffusion/models.py b/demo/Diffusion/models.py index 162eb6adc..d9d82b69d 100644 --- a/demo/Diffusion/models.py +++ b/demo/Diffusion/models.py @@ -19,8 +19,10 @@ from diffusers.loaders import LoraLoaderMixin from diffusers.models import ( AutoencoderKL, + AutoencoderKLTemporalDecoder, ControlNetModel, - UNet2DConditionModel + UNet2DConditionModel, + UNetSpatioTemporalConditionModel, ) import json import numpy as np @@ -35,9 +37,11 @@ import torch import torch.nn.functional as F from transformers import ( + CLIPImageProcessor, CLIPTextModel, CLIPTextModelWithProjection, - CLIPTokenizer + CLIPTokenizer, + CLIPVisionModelWithProjection, ) from huggingface_hub import hf_hub_download from utilities import merge_loras @@ -168,49 +172,38 @@ def fuse_mha_qkv_int8_sq(self): def get_path(version, pipeline, controlnets=None): if controlnets is not None: return ["lllyasviel/sd-controlnet-" + modality for modality in controlnets] - - if version == "1.4": - if pipeline.is_inpaint(): - return "runwayml/stable-diffusion-inpainting" - else: - return "CompVis/stable-diffusion-v1-4" + + if version in ("1.4", "1.5") and pipeline.is_inpaint(): + return "runwayml/stable-diffusion-inpainting" + elif version == "1.4": + return "CompVis/stable-diffusion-v1-4" elif version == "1.5": - if pipeline.is_inpaint(): - return "runwayml/stable-diffusion-inpainting" - else: - return "runwayml/stable-diffusion-v1-5" + return "runwayml/stable-diffusion-v1-5" elif version == 'dreamshaper-7': return 'Lykon/dreamshaper-7' + elif version in ("2.0-base", "2.0") and pipeline.is_inpaint(): + return "stabilityai/stable-diffusion-2-inpainting" elif version == "2.0-base": - if pipeline.is_inpaint(): - return "stabilityai/stable-diffusion-2-inpainting" - else: - return "stabilityai/stable-diffusion-2-base" + return "stabilityai/stable-diffusion-2-base" elif version == "2.0": - if pipeline.is_inpaint(): - return "stabilityai/stable-diffusion-2-inpainting" - else: - return "stabilityai/stable-diffusion-2" - elif version == "2.1": - return "stabilityai/stable-diffusion-2-1" + return "stabilityai/stable-diffusion-2" elif version == "2.1-base": return "stabilityai/stable-diffusion-2-1-base" - elif version == 'xl-1.0': - if pipeline.is_sd_xl_base(): - return "stabilityai/stable-diffusion-xl-base-1.0" - elif pipeline.is_sd_xl_refiner(): - return "stabilityai/stable-diffusion-xl-refiner-1.0" - else: - raise ValueError(f"Unsupported SDXL 1.0 pipeline {pipeline.name}") - elif version == 'xl-turbo': - if pipeline.is_sd_xl_base(): - return "stabilityai/sdxl-turbo" - else: - raise ValueError(f"Unsupported SDXL Turbo pipeline {pipeline.name}") + elif version == "2.1": + return "stabilityai/stable-diffusion-2-1" + elif version == 'xl-1.0' and pipeline.is_sd_xl_base(): + return "stabilityai/stable-diffusion-xl-base-1.0" + elif version == 'xl-1.0' and pipeline.is_sd_xl_refiner(): + return "stabilityai/stable-diffusion-xl-refiner-1.0" + # TODO SDXL turbo with refiner + elif version == 'xl-turbo' and pipeline.is_sd_xl_base(): + return "stabilityai/sdxl-turbo" elif version == 'sd3': return "stabilityai/stable-diffusion-3-medium" + elif version == 'svd-xt-1.1' and pipeline.is_img2vid(): + return "stabilityai/stable-video-diffusion-img2vid-xt-1-1" else: - raise ValueError(f"Incorrect version {version}") + raise ValueError(f"Unsupported version {version} + pipeline {pipeline.name}") def get_clip_embedding_dim(version, pipeline): if version in ("1.4", "1.5", "dreamshaper-7"): @@ -239,11 +232,13 @@ def get_unet_embedding_dim(version, pipeline): return 2048 elif version in ("xl-1.0", "xl-turbo") and pipeline.is_sd_xl_refiner(): return 1280 + elif pipeline.is_img2vid(): + return 1024 else: raise ValueError(f"Invalid version {version} + pipeline {pipeline}") -# FIXME after serialization support for torch.compile is added -def get_checkpoint_dir(framework_model_dir, version, pipeline, subfolder, torch_inference): +# FIXME serialization not supported for torch.compile +def get_checkpoint_dir(framework_model_dir, version, pipeline, subfolder): return os.path.join(framework_model_dir, version, pipeline, subfolder) torch_inference_modes = ['default', 'reduce-overhead', 'max-autotune'] @@ -400,14 +395,14 @@ def export_onnx(model): model = merge_loras(model, self.lora_dict, self.lora_alphas, self.lora_scales) inputs = self.get_sample_input(1, opt_image_height, opt_image_width, static_shape) torch.onnx.export(model, - inputs, - onnx_path, - export_params=True, - opset_version=onnx_opset, - do_constant_folding=True, - input_names=self.get_input_names(), - output_names=self.get_output_names(), - dynamic_axes=self.get_dynamic_axes(), + inputs, + onnx_path, + export_params=True, + opset_version=onnx_opset, + do_constant_folding=True, + input_names=self.get_input_names(), + output_names=self.get_output_names(), + dynamic_axes=self.get_dynamic_axes(), ) if custom_model: with torch.inference_mode(): @@ -544,7 +539,7 @@ def __init__(self, self.extra_output_names = ['hidden_states'] def get_model(self, torch_inference=''): - clip_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + clip_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) if not os.path.exists(clip_model_dir): model = CLIPTextModel.from_pretrained(self.path, subfolder=self.subfolder, @@ -552,7 +547,7 @@ def get_model(self, torch_inference=''): use_auth_token=self.hf_token).to(self.device) model.save_pretrained(clip_model_dir) else: - print(f"[I] Load CLIP pytorch model from: {clip_model_dir}") + print(f"[I] Load CLIPTextModel model from: {clip_model_dir}") model = CLIPTextModel.from_pretrained(clip_model_dir).to(self.device) model = optimize_checkpoint(model, torch_inference) return model @@ -630,7 +625,7 @@ def __init__(self, self.subfolder = subfolder def get_model(self, torch_inference=''): - clip_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + clip_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) if not os.path.exists(clip_model_dir): model = CLIPTextModelWithProjection.from_pretrained(self.path, subfolder=self.subfolder, @@ -638,7 +633,7 @@ def get_model(self, torch_inference=''): use_auth_token=self.hf_token).to(self.device) model.save_pretrained(clip_model_dir) else: - print(f"[I] Load CLIP pytorch model from: {clip_model_dir}") + print(f"[I] Load CLIPTextModelWithProjection model from: {clip_model_dir}") model = CLIPTextModelWithProjection.from_pretrained(clip_model_dir).to(self.device) model = optimize_checkpoint(model, torch_inference) return model @@ -664,10 +659,10 @@ def __init__(self, verbose, framework_model_dir, max_batch_size, - embedding_dim, + embedding_dim=None, fp16=False, + pooled_output=False, ): - super(SD3_CLIPGModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, fp16=fp16, max_batch_size=max_batch_size, embedding_dim=embedding_dim) self.CLIPG_CONFIG = { "hidden_act": "gelu", "hidden_size": 1280, @@ -675,17 +670,20 @@ def __init__(self, "num_attention_heads": 20, "num_hidden_layers": 32 } + super(SD3_CLIPGModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, fp16=fp16, max_batch_size=max_batch_size, embedding_dim=self.CLIPG_CONFIG["hidden_size"] if embedding_dim is None else embedding_dim) self.subfolder = 'text_encoders' + if pooled_output: + self.extra_output_names = ['pooled_output'] def get_model(self, torch_inference=''): - clip_g_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + clip_g_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) clip_g_filename="clip_g.safetensors" clip_g_model_path = f"{clip_g_model_dir}/{clip_g_filename}" if not os.path.exists(clip_g_model_path): hf_hub_download( repo_id=self.path, filename=clip_g_filename, - local_dir=get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, '', torch_inference), + local_dir=get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, ''), subfolder=self.subfolder ) with safe_open(clip_g_model_path, framework="pt", device=self.device) as f: @@ -695,7 +693,33 @@ def get_model(self, torch_inference=''): model = optimize_checkpoint(model, torch_inference) return model -class SD3_CLIPLModel(CLIPModel): + def get_shape_dict(self, batch_size, image_height, image_width): + self.check_dims(batch_size, image_height, image_width) + output = { + 'input_ids': (batch_size, self.text_maxlen), + 'text_embeddings': (batch_size, self.text_maxlen, self.embedding_dim) + } + if 'pooled_output' in self.extra_output_names: + output["pooled_output"] = (batch_size, self.embedding_dim) + + return output + + def optimize(self, onnx_graph): + opt = Optimizer(onnx_graph, verbose=self.verbose) + opt.info(self.name + ': original') + opt.select_outputs([0, 1]) + opt.cleanup() + opt.fold_constants() + opt.info(self.name + ': fold constants') + opt.infer_shapes() + opt.info(self.name + ': shape inference') + opt.select_outputs([0, 1], names=['text_embeddings', 'pooled_output']) # rename network output + opt.info(self.name + ': rename output[0] and output[1]') + opt_onnx_graph = opt.cleanup(return_onnx=True) + opt.info(self.name + ': finished') + return opt_onnx_graph + +class SD3_CLIPLModel(SD3_CLIPGModel): def __init__(self, version, pipeline, @@ -704,10 +728,9 @@ def __init__(self, verbose, framework_model_dir, max_batch_size, - embedding_dim, fp16=False, + pooled_output=False, ): - super(SD3_CLIPLModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, fp16=fp16, max_batch_size=max_batch_size, embedding_dim=embedding_dim) self.CLIPL_CONFIG = { "hidden_act": "quick_gelu", "hidden_size": 768, @@ -715,17 +738,20 @@ def __init__(self, "num_attention_heads": 12, "num_hidden_layers": 12 } + super(SD3_CLIPLModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, fp16=fp16, max_batch_size=max_batch_size, embedding_dim=self.CLIPL_CONFIG["hidden_size"]) self.subfolder = 'text_encoders' + if pooled_output: + self.extra_output_names = ['pooled_output'] def get_model(self, torch_inference=''): - clip_l_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + clip_l_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) clip_l_filename="clip_l.safetensors" clip_l_model_path = f"{clip_l_model_dir}/{clip_l_filename}" if not os.path.exists(clip_l_model_path): hf_hub_download( repo_id=self.path, filename=clip_l_filename, - local_dir=get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, '', torch_inference), + local_dir=get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, ''), subfolder=self.subfolder ) with safe_open(clip_l_model_path, framework="pt", device=self.device) as f: @@ -758,14 +784,14 @@ def __init__(self, self.subfolder = 'text_encoders' def get_model(self, torch_inference=''): - t5xxl_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + t5xxl_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) t5xxl_filename="t5xxl_fp16.safetensors" t5xxl_model_path = f"{t5xxl_model_dir}/{t5xxl_filename}" if not os.path.exists(t5xxl_model_path): hf_hub_download( repo_id=self.path, filename=t5xxl_filename, - local_dir=get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, '', torch_inference), + local_dir=get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, ''), subfolder=self.subfolder ) with safe_open(t5xxl_model_path, framework="pt", device=self.device) as f: @@ -775,6 +801,67 @@ def get_model(self, torch_inference=''): model = optimize_checkpoint(model, torch_inference) return model +class CLIPVisionWithProjModel(BaseModel): + def __init__(self, + version, + pipeline, + device, + hf_token, + verbose, + framework_model_dir, + max_batch_size=1, + subfolder="image_encoder", + ): + + super(CLIPVisionWithProjModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, max_batch_size=max_batch_size) + self.subfolder = subfolder + + def get_model(self, torch_inference=''): + clip_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) + if not os.path.exists(clip_model_dir): + model = CLIPVisionModelWithProjection.from_pretrained(self.path, + subfolder=self.subfolder, + use_safetensors=self.hf_safetensor, + use_auth_token=self.hf_token).to(self.device) + model.save_pretrained(clip_model_dir) + else: + print(f"[I] Load CLIPVisionModelWithProjection model from: {clip_model_dir}") + model = CLIPVisionModelWithProjection.from_pretrained(clip_model_dir).to(self.device) + model = optimize_checkpoint(model, torch_inference) + return model + + +class CLIPImageProcessorModel(BaseModel): + def __init__(self, + version, + pipeline, + device, + hf_token, + verbose, + framework_model_dir, + max_batch_size=1, + subfolder="feature_extractor", + ): + + super(CLIPImageProcessorModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, max_batch_size=max_batch_size) + self.subfolder = subfolder + + def get_model(self, torch_inference=''): + clip_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) + # NOTE to(device) not supported + if not os.path.exists(clip_model_dir): + model = CLIPImageProcessor.from_pretrained(self.path, + subfolder=self.subfolder, + use_safetensors=self.hf_safetensor, + use_auth_token=self.hf_token) + model.save_pretrained(clip_model_dir) + else: + print(f"[I] Load CLIPImageProcessor model from: {clip_model_dir}") + model = CLIPImageProcessor.from_pretrained(clip_model_dir) + model = optimize_checkpoint(model, torch_inference) + return model + + class UNet2DConditionControlNetModel(torch.nn.Module): def __init__(self, unet, controlnets) -> None: super().__init__() @@ -858,7 +945,7 @@ def get_model(self, torch_inference=''): # FIXME - cache UNet2DConditionControlNetModel model = UNet2DConditionControlNetModel(unet_model, controlnets) else: - unet_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + unet_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) unet_path = self.get_model_path(unet_model_dir, model_opts) if not os.path.exists(unet_path): model = UNet2DConditionModel.from_pretrained(self.path, @@ -868,7 +955,7 @@ def get_model(self, torch_inference=''): **model_opts).to(self.device) model.save_pretrained(unet_model_dir, **model_opts) else: - print(f"[I] Load UNet pytorch model from: {unet_path}") + print(f"[I] Load UNet2DConditionModel model from: {unet_path}") model = UNet2DConditionModel.from_pretrained(unet_model_dir, **model_opts).to(self.device) if torch_inference: model.to(memory_format=torch.channels_last) @@ -996,7 +1083,7 @@ def __init__(self, def get_model(self, torch_inference=''): model_opts = {'variant': 'fp16', 'torch_dtype': torch.float16} if self.fp16 else {} - unet_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + unet_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) unet_path = self.get_model_path(unet_model_dir, model_opts) if not os.path.exists(unet_path): model = UNet2DConditionModel.from_pretrained(self.path, @@ -1009,7 +1096,7 @@ def get_model(self, torch_inference=''): model.set_default_attn_processor() model.save_pretrained(unet_model_dir, **model_opts) else: - print(f"[I] Load UNet pytorch model from: {unet_path}") + print(f"[I] Load UNet2DConditionModel model from: {unet_path}") model = UNet2DConditionModel.from_pretrained(unet_model_dir, **model_opts).to(self.device) model = optimize_checkpoint(model, torch_inference) return model @@ -1100,7 +1187,7 @@ def __init__(self, self.xB = 2 def get_model(self, torch_inference=''): - sd3_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + sd3_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) sd3_filename="sd3_medium.safetensors" sd3_model_path = f"{sd3_model_dir}/{sd3_filename}" if not os.path.exists(sd3_model_path): @@ -1160,6 +1247,92 @@ def get_sample_input(self, batch_size, image_height, image_width, static_shape): } ) + +class UNetTemporalModel(BaseModel): + def __init__(self, + version, + pipeline, + device, + hf_token, + verbose, + framework_model_dir, + fp16 = False, + max_batch_size = 16, + num_frames = 14, + do_classifier_free_guidance = True, + ): + super(UNetTemporalModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, fp16=fp16, max_batch_size=max_batch_size, embedding_dim=get_unet_embedding_dim(version, pipeline)) + self.subfolder = 'unet' + self.unet_dim = 4 + self.num_frames = num_frames + self.out_channels = 4 + self.cross_attention_dim = 1024 + self.xB = 2 if do_classifier_free_guidance else 1 # batch multiplier + + def get_model(self, torch_inference=''): + model_opts = {'variant': 'fp16', 'torch_dtype': torch.float16} if self.fp16 else {} + unet_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) + unet_path = self.get_model_path(unet_model_dir, model_opts) + if not os.path.exists(unet_path): + model = UNetSpatioTemporalConditionModel.from_pretrained(self.path, + subfolder=self.subfolder, + use_safetensors=self.hf_safetensor, + use_auth_token=self.hf_token, + **model_opts).to(self.device) + model.save_pretrained(unet_model_dir, **model_opts) + else: + print(f"[I] Load UNetSpatioTemporalConditionModel model from: {unet_path}") + model = UNetSpatioTemporalConditionModel.from_pretrained(unet_model_dir, **model_opts).to(self.device) + model = optimize_checkpoint(model, torch_inference) + return model + + def get_input_names(self): + return ['sample', 'timestep', 'encoder_hidden_states', 'added_time_ids'] + + def get_output_names(self): + return ['latent'] + + def get_dynamic_axes(self): + xB = str(self.xB)+'B' + return { + 'sample': {0: xB, 1: 'num_frames', 3: 'H', 4: 'W'}, + 'encoder_hidden_states': {0: xB}, + 'added_time_ids': {0: xB} + } + + def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape): + latent_height, latent_width = self.check_dims(batch_size, image_height, image_width) + min_batch, max_batch, min_image_height, max_image_height, min_image_width, max_image_width, min_latent_height, max_latent_height, min_latent_width, max_latent_width = \ + self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape) + return { + 'sample': [(self.xB*min_batch, self.num_frames, 2*self.out_channels, min_latent_height, min_latent_width), (self.xB*batch_size, self.num_frames, 2*self.out_channels, latent_height, latent_width), (self.xB*max_batch, self.num_frames, 2*self.out_channels, max_latent_height, max_latent_width)], + 'encoder_hidden_states': [(self.xB*min_batch, 1, self.cross_attention_dim), (self.xB*batch_size, 1, self.cross_attention_dim), (self.xB*max_batch, 1, self.cross_attention_dim)], + 'added_time_ids': [(self.xB*min_batch, 3), (self.xB*batch_size, 3), (self.xB*max_batch, 3)], + } + + + def get_shape_dict(self, batch_size, image_height, image_width): + latent_height, latent_width = self.check_dims(batch_size, image_height, image_width) + return { + 'sample': (self.xB*batch_size, self.num_frames, 2*self.out_channels, latent_height, latent_width), + 'timestep': (1,), + 'encoder_hidden_states': (self.xB*batch_size, 1, self.cross_attention_dim), + 'added_time_ids': (self.xB*batch_size, 3), + } + + def get_sample_input(self, batch_size, image_height, image_width): + # TODO chunk_size if forward_chunking is used + latent_height, latent_width = self.check_dims(batch_size, image_height, image_width) + + dtype = torch.float16 if self.fp16 else torch.float32 + return ( + torch.randn(self.xB*batch_size, self.num_frames, 2*self.out_channels, latent_height, latent_width, dtype=dtype, device=self.device), + torch.tensor([1.], dtype=torch.float32, device=self.device), + torch.randn(self.xB*batch_size, 1, self.cross_attention_dim, dtype=dtype, device=self.device), + torch.randn(self.xB*batch_size, 3, dtype=dtype, device=self.device), + ) + + class VAEModel(BaseModel): def __init__(self, version, @@ -1175,7 +1348,7 @@ def __init__(self, self.subfolder = 'vae' def get_model(self, torch_inference=''): - vae_decoder_model_path = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + vae_decoder_model_path = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) if not os.path.exists(vae_decoder_model_path): model = AutoencoderKL.from_pretrained(self.path, subfolder=self.subfolder, @@ -1183,7 +1356,7 @@ def get_model(self, torch_inference=''): use_auth_token=self.hf_token).to(self.device) model.save_pretrained(vae_decoder_model_path) else: - print(f"[I] Load VAE decoder pytorch model from: {vae_decoder_model_path}") + print(f"[I] Load AutoencoderKL (decoder) model from: {vae_decoder_model_path}") model = AutoencoderKL.from_pretrained(vae_decoder_model_path).to(self.device) model.forward = model.decode model = optimize_checkpoint(model, torch_inference) @@ -1236,7 +1409,7 @@ def __init__(self, def get_model(self, torch_inference=''): dtype = torch.float16 if self.fp16 else torch.float32 - sd3_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + sd3_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) sd3_filename="sd3_medium.safetensors" sd3_model_path = f"{sd3_model_dir}/{sd3_filename}" if not os.path.exists(sd3_model_path): @@ -1271,10 +1444,80 @@ def get_sample_input(self, batch_size, image_height, image_width, static_shape): dtype = torch.float16 if self.fp16 else torch.float32 return torch.randn(batch_size, 16, latent_height, latent_width, dtype=dtype, device=self.device) +class VAEDecTemporalModel(BaseModel): + def __init__(self, + version, + pipeline, + device, + hf_token, + verbose, + framework_model_dir, + max_batch_size = 16, + decode_chunk_size = 14, + ): + super(VAEDecTemporalModel, self).__init__(version, pipeline, device=device, hf_token=hf_token, verbose=verbose, framework_model_dir=framework_model_dir, max_batch_size=max_batch_size) + self.subfolder = 'vae' + self.decode_chunk_size = decode_chunk_size + + def get_model(self, torch_inference=''): + vae_decoder_model_path = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) + if not os.path.exists(vae_decoder_model_path): + model = AutoencoderKLTemporalDecoder.from_pretrained(self.path, + subfolder=self.subfolder, + use_safetensors=self.hf_safetensor, + use_auth_token=self.hf_token).to(self.device) + model.save_pretrained(vae_decoder_model_path) + else: + print(f"[I] Load AutoencoderKLTemporalDecoder model from: {vae_decoder_model_path}") + model = AutoencoderKLTemporalDecoder.from_pretrained(vae_decoder_model_path).to(self.device) + model.forward = model.decode + model = optimize_checkpoint(model, torch_inference) + return model + + def get_input_names(self): + return ['latent', 'num_frames_in'] + + def get_output_names(self): + return ['frames'] + + def get_dynamic_axes(self): + return { + 'latent': {0: 'num_frames_in', 2: 'H', 3: 'W'}, + 'frames': {0: 'num_frames_in', 2: '8H', 3: '8W'} + } + + def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape): + latent_height, latent_width = self.check_dims(batch_size, image_height, image_width) + assert batch_size == 1 + _, _, _, _, _, _, min_latent_height, max_latent_height, min_latent_width, max_latent_width = \ + self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape) + return { + 'latent': [(1, 4, min_latent_height, min_latent_width), (self.decode_chunk_size, 4, latent_height, latent_width), (self.decode_chunk_size, 4, max_latent_height, max_latent_width)], + 'num_frames_in': [(1,), (1,), (1,)], + } + + def get_shape_dict(self, batch_size, image_height, image_width): + latent_height, latent_width = self.check_dims(batch_size, image_height, image_width) + assert batch_size == 1 + return { + 'latent': (self.decode_chunk_size, 4, latent_height, latent_width), + #'num_frames_in': (1,), + 'frames': (self.decode_chunk_size, 3, image_height, image_width) + } + + def get_sample_input(self, batch_size, image_height, image_width): + latent_height, latent_width = self.check_dims(batch_size, image_height, image_width) + assert batch_size == 1 + return ( + torch.randn(self.decode_chunk_size, 4, latent_height, latent_width, dtype=torch.float32, device=self.device), + self.decode_chunk_size, + ) + + class TorchVAEEncoder(torch.nn.Module): def __init__(self, version, pipeline, hf_token, device, path, framework_model_dir, hf_safetensor=False): super().__init__() - vae_encoder_model_dir = get_checkpoint_dir(framework_model_dir, version, pipeline, 'vae_encoder', '') + vae_encoder_model_dir = get_checkpoint_dir(framework_model_dir, version, pipeline, 'vae_encoder') if not os.path.exists(vae_encoder_model_dir): self.vae_encoder = AutoencoderKL.from_pretrained(path, subfolder='vae', @@ -1282,7 +1525,7 @@ def __init__(self, version, pipeline, hf_token, device, path, framework_model_di use_auth_token=hf_token).to(device) self.vae_encoder.save_pretrained(vae_encoder_model_dir) else: - print(f"[I] Load VAE encoder pytorch model from: {vae_encoder_model_dir}") + print(f"[I] Load AutoencoderKL (encoder) model from: {vae_encoder_model_dir}") self.vae_encoder = AutoencoderKL.from_pretrained(vae_encoder_model_dir).to(device) def forward(self, x): @@ -1357,7 +1600,7 @@ def __init__(self, def get_model(self, torch_inference=''): dtype = torch.float16 if self.fp16 else torch.float32 - sd3_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder, torch_inference) + sd3_model_dir = get_checkpoint_dir(self.framework_model_dir, self.version, self.pipeline, self.subfolder) sd3_filename="sd3_medium.safetensors" sd3_model_path = f"{sd3_model_dir}/{sd3_filename}" if not os.path.exists(sd3_model_path): @@ -1391,7 +1634,7 @@ def get_sample_input(self, batch_size, image_height, image_width, static_shape): return torch.randn(batch_size, 3, image_height, image_width, dtype=dtype, device=self.device) def make_tokenizer(version, pipeline, hf_token, framework_model_dir, subfolder="tokenizer", **kwargs): - tokenizer_model_dir = get_checkpoint_dir(framework_model_dir, version, pipeline.name, subfolder, '') + tokenizer_model_dir = get_checkpoint_dir(framework_model_dir, version, pipeline.name, subfolder) if not os.path.exists(tokenizer_model_dir): model = CLIPTokenizer.from_pretrained(get_path(version, pipeline), subfolder=subfolder, @@ -1399,6 +1642,6 @@ def make_tokenizer(version, pipeline, hf_token, framework_model_dir, subfolder=" use_auth_token=hf_token) model.save_pretrained(tokenizer_model_dir) else: - print(f"[I] Load tokenizer pytorch model from: {tokenizer_model_dir}") + print(f"[I] Load CLIPTokenizer model from: {tokenizer_model_dir}") model = CLIPTokenizer.from_pretrained(tokenizer_model_dir) return model diff --git a/demo/Diffusion/requirements.txt b/demo/Diffusion/requirements.txt old mode 100644 new mode 100755 index 8874c6618..fc2979b51 --- a/demo/Diffusion/requirements.txt +++ b/demo/Diffusion/requirements.txt @@ -9,7 +9,7 @@ onnx==1.15.0 onnxruntime==1.16.3 opencv-python==4.8.0.74 scipy -transformers==4.33.1 +transformers==4.36.2 --extra-index-url https://pypi.nvidia.com nvidia-modelopt==0.11.2 onnx-graphsurgeon diff --git a/demo/Diffusion/stable_diffusion_3_pipeline.py b/demo/Diffusion/stable_diffusion_3_pipeline.py index 33059ea43..ea691e966 100644 --- a/demo/Diffusion/stable_diffusion_3_pipeline.py +++ b/demo/Diffusion/stable_diffusion_3_pipeline.py @@ -250,15 +250,14 @@ def loadEngines( self.tokenizer = SD3Tokenizer() # Load text encoders - embedding_dim = get_clip_embedding_dim(self.version, self.pipeline_type) if 'clip_g' in self.stages: - self.models['clip_g'] = SD3_CLIPGModel(**models_args, fp16=True, embedding_dim=embedding_dim) + self.models['clip_g'] = SD3_CLIPGModel(**models_args, fp16=True, pooled_output=True) if 'clip_l' in self.stages: - self.models['clip_l'] = SD3_CLIPLModel(**models_args, fp16=True, embedding_dim=embedding_dim) + self.models['clip_l'] = SD3_CLIPLModel(**models_args, fp16=True, pooled_output=True) if 't5xxl' in self.stages: - self.models['t5xxl'] = SD3_T5XXLModel(**models_args, fp16=True, embedding_dim=embedding_dim) + self.models['t5xxl'] = SD3_T5XXLModel(**models_args, fp16=True, embedding_dim=get_clip_embedding_dim(self.version, self.pipeline_type)) # Load MMDiT model if 'mmdit' in self.stages: @@ -275,7 +274,7 @@ def loadEngines( # Configure pipeline models to load model_names = self.models.keys() # Torch fallback - self.torch_fallback = dict(zip(model_names, [self.torch_inference or model_name in ('clip_g', 'clip_l', 't5xxl') for model_name in model_names])) + self.torch_fallback = dict(zip(model_names, [self.torch_inference or model_name in ('t5xxl') for model_name in model_names])) onnx_path = dict(zip(model_names, [self.getOnnxPath(model_name, onnx_dir, opt=False) for model_name in model_names])) onnx_opt_path = dict(zip(model_names, [self.getOnnxPath(model_name, onnx_dir) for model_name in model_names])) @@ -334,7 +333,7 @@ def activateEngines(self, shared_device_memory=None): self.shared_device_memory = shared_device_memory # Load and activate TensorRT engines for engine in self.engine.values(): - engine.activate(reuse_device_memory=self.shared_device_memory) + engine.activate(device_memory=self.shared_device_memory) def runEngine(self, model_name, feed_dict): engine = self.engine[model_name] @@ -374,7 +373,8 @@ def print_summary(self, denoising_steps, walltime_ms, batch_size): def save_image(self, images, pipeline, prompt, seed): # Save image image_name_prefix = pipeline+''.join(set(['-'+prompt[i].replace(' ','_')[:10] for i in range(len(prompt))]))+'-'+str(seed)+'-' - save_image(images, self.output_dir, image_name_prefix) + image_name_suffix = 'torch' if self.torch_inference else 'trt' + save_image(images, self.output_dir, image_name_prefix, image_name_suffix) def encode_prompt(self, prompt, negative_prompt): def encode_token_weights(model_name, token_weight_pairs): @@ -385,8 +385,8 @@ def encode_token_weights(model_name, token_weight_pairs): if self.torch_inference or self.torch_fallback[model_name]: out, pooled = self.torch_models[model_name](tokens) else: - out = self.runEngine('t5xxl', {'input_ids': tokens})['text_embeddings'] - pooled = None + trt_out = self.runEngine(model_name, {'input_ids': tokens}) + out, pooled = trt_out['text_embeddings'], trt_out["pooled_output"] self.profile_stop(model_name) diff --git a/demo/Diffusion/stable_diffusion_pipeline.py b/demo/Diffusion/stable_diffusion_pipeline.py old mode 100755 new mode 100644 index 9a1761ca0..c1316c66f --- a/demo/Diffusion/stable_diffusion_pipeline.py +++ b/demo/Diffusion/stable_diffusion_pipeline.py @@ -169,6 +169,8 @@ def __init__( self.stages.append('vae') elif self.pipeline_type.is_sd_xl_refiner(): self.stages = ['clip2', 'unetxl', 'vae'] + elif self.pipeline_type.is_img2vid(): + self.stages = ['clip-vis', 'clip-imgfe', 'unet-temp', 'vae-temp'] else: raise ValueError(f"Unsupported pipeline {self.pipeline_type.name}.") self.return_latents = return_latents @@ -183,7 +185,8 @@ def __init__( '2.1-base': 'PNDM', '2.1': 'DDIM', 'xl-1.0' : 'Euler', - 'xl-turbo': 'EulerA' + 'xl-turbo': 'EulerA', + 'svd-xt-1.1': 'Euler' } if not scheduler: @@ -273,6 +276,9 @@ def teardown(self): if self.shared_device_memory: cudart.cudaFree(self.shared_device_memory) + for torch_model in self.torch_models.values(): + del torch_model + cudart.cudaStreamDestroy(self.stream) del self.stream @@ -324,7 +330,6 @@ def loadEngines( quantization_alpha=0.8, calibration_size=32, calib_batch_size=2, - denoising_steps=30, ): """ Build and load engines for TensorRT accelerated inference. @@ -370,9 +375,6 @@ def loadEngines( Recommendation: 32, 64, 128 for SDXL calib_batch_size (int): The batch size to use for calibration. Defaults to 2. - denoising_steps (int): - The number of denoising steps. - More denoising steps usually lead to a higher quality image at the expense of slower inference. """ # Create directories if missing for directory in [engine_dir, onnx_dir]: @@ -435,7 +437,7 @@ def loadEngines( if int8: assert self.pipeline_type.is_sd_xl_base(), "int8 quantization only supported for SDXL pipeline" use_int8['unetxl'] = True - model_suffix['unetxl'] += f"-int8.l{quantization_level}.bs2.s{denoising_steps}.c{calibration_size}.p{quantization_percentile}.a{quantization_alpha}" + model_suffix['unetxl'] += f"-int8.l{quantization_level}.bs2.s{self.denoising_steps}.c{calibration_size}.p{quantization_percentile}.a{quantization_alpha}" onnx_path = dict(zip(model_names, [self.getOnnxPath(model_name, onnx_dir, opt=False, suffix=model_suffix[model_name]) for model_name in model_names])) onnx_opt_path = dict(zip(model_names, [self.getOnnxPath(model_name, onnx_dir, suffix=model_suffix[model_name]) for model_name in model_names])) engine_path = dict(zip(model_names, [self.getEnginePath(model_name, engine_dir, do_engine_refit[model_name], suffix=model_suffix[model_name]) for model_name in model_names])) @@ -465,7 +467,7 @@ def loadEngines( quantization_level, quantization_alpha, quantization_percentile, - denoising_steps + self.denoising_steps ) def do_calibrate(base, calibration_prompts, **kwargs): @@ -487,7 +489,7 @@ def calibration_loop(unet): base=pipeline, calibration_prompts=calibration_prompts, calib_size=calibration_size // calib_batch_size, - n_steps=denoising_steps, + n_steps=self.denoising_steps, ) print(f"[I] Performing int8 calibration for {calibration_size} steps.") @@ -580,7 +582,7 @@ def activateEngines(self, shared_device_memory=None): self.shared_device_memory = shared_device_memory # Load and activate TensorRT engines for engine in self.engine.values(): - engine.activate(reuse_device_memory=self.shared_device_memory) + engine.activate(device_memory=self.shared_device_memory) def runEngine(self, model_name, feed_dict): engine = self.engine[model_name] @@ -830,7 +832,8 @@ def print_summary(self, denoising_steps, walltime_ms, batch_size): def save_image(self, images, pipeline, prompt, seed): # Save image image_name_prefix = pipeline+''.join(set(['-'+prompt[i].replace(' ','_')[:10] for i in range(len(prompt))]))+'-'+str(seed)+'-' - save_image(images, self.output_dir, image_name_prefix) + image_name_suffix = 'torch' if self.torch_inference else 'trt' + save_image(images, self.output_dir, image_name_prefix, image_name_suffix) def infer( self, diff --git a/demo/Diffusion/stable_video_diffusion_pipeline.py b/demo/Diffusion/stable_video_diffusion_pipeline.py new file mode 100644 index 000000000..e2370539e --- /dev/null +++ b/demo/Diffusion/stable_video_diffusion_pipeline.py @@ -0,0 +1,641 @@ +# +# Copyright 2024 The HuggingFace Inc. team. +# SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +from cuda import cudart +from diffusers.image_processor import VaeImageProcessor +from diffusers.utils.torch_utils import randn_tensor +from models import ( + CLIPImageProcessorModel, + CLIPVisionWithProjModel, + UNetTemporalModel, + VAEDecTemporalModel, +) +import os +import pathlib +import tensorrt as trt +import time +import torch +import random +from tqdm.auto import tqdm +from typing import Optional +from utilities import ( + GiB, + PIPELINE_TYPE, + TRT_LOGGER, + Engine, + _append_dims, + _resize_with_antialiasing, + tensor2vid, +) +from stable_diffusion_pipeline import StableDiffusionPipeline + +class StableVideoDiffusionPipeline(StableDiffusionPipeline): + """ + Application showcasing the acceleration of Stable Video Diffusion pipelines using NVidia TensorRT. + """ + def __init__( + self, + version='svd-xt-1.1', + pipeline_type=PIPELINE_TYPE.IMG2VID, + min_guidance_scale: float = 1.0, + max_guidance_scale: float = 3.0, + decode_chunk_size: Optional[int] = None, + **kwargs + ): + """ + Initializes the Diffusion pipeline. + + Args: + version (str): + The version of the pipeline. Should be one of [svd-xt-1.1] + pipeline_type (PIPELINE_TYPE): + Type of current pipeline. + min_guidance_scale (`float`, *optional*, defaults to 1.0): + The minimum guidance scale. Used for the classifier free guidance with first frame. + max_guidance_scale (`float`, *optional*, defaults to 3.0): + The maximum guidance scale. Used for the classifier free guidance with last frame. + `max_guidance_scale = 1` corresponds to doing no classifier free guidance. + decode_chunk_size (`int`, *optional*): + The number of frames to decode at a time. The higher the chunk size, the higher the temporal consistency + between frames, but also the higher the memory consumption. By default, the decoder will decode all frames at once + for maximal quality. Reduce `decode_chunk_size` to reduce memory usage. + """ + super().__init__( + version=version, + pipeline_type=pipeline_type, + **kwargs + ) + self.min_guidance_scale = min_guidance_scale + self.max_guidance_scale = max_guidance_scale + self.do_classifier_free_guidance = max_guidance_scale > 1 + # FIXME vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) + self.vae_scale_factor = 8 + # FIXME num_frames = self.config.num_frames + select_num_frames = { + 'svd-xt-1.1': 25, + } + self.num_frames = select_num_frames.get(version, 14) + # TODO decode_chunk_size from args + self.decode_chunk_size = 8 if not decode_chunk_size else decode_chunk_size + # TODO: scaling_factor = vae.config.scaling_factor + self.scaling_factor = 0.18215 + + # TODO user configurable cuda_device_id + cuda_device_id = 0 + vram_size = cudart.cudaGetDeviceProperties(cuda_device_id)[1].totalGlobalMem + self.low_vram = vram_size < GiB(40) + if self.low_vram: + print(f"[W] WARNING low VRAM ({vram_size/GiB(1):.2f} GB) mode selected. Certain optimizations may be skipped.") + if self.use_cuda_graph and self.low_vram: + print(f"[W] WARNING CUDA graph disabled in low VRAM mode.") + self.use_cuda_graph = False + + self.config = {} + if self.pipeline_type.is_img2vid(): + self.config['clip_vis_torch_fallback'] = True + self.config['clip_imgfe_torch_fallback'] = True + self.config['vae_temp_torch_fallback'] = True + + # initialized in loadEngines() + self.max_shared_device_memory_size = 0 + + def loadResources(self, image_height, image_width, batch_size, seed): + # Initialize noise generator + self.seed = seed + self.generator = torch.Generator(device="cuda").manual_seed(seed) if seed else None + + # Create CUDA events and stream + for stage in ['clip', 'denoise', 'vae', 'vae_encoder']: + self.events[stage] = [cudart.cudaEventCreate()[1], cudart.cudaEventCreate()[1]] + self.stream = cudart.cudaStreamCreate()[1] + + # Allocate shared device memory for TensorRT engines + if not self.low_vram and not self.torch_inference: + for model_name in self.models.keys(): + if not self.torch_fallback[model_name]: + self.max_shared_device_memory_size = max(self.max_shared_device_memory_size, self.engine[model_name].engine.device_memory_size) + self.shared_device_memory = cudart.cudaMalloc(self.max_shared_device_memory_size)[1] + # Activate TensorRT engines + for model_name in self.models.keys(): + if not self.torch_fallback[model_name]: + self.engine[model_name].activate(device_memory=self.shared_device_memory) + alloc_shape = self.models[model_name].get_shape_dict(batch_size, image_height, image_width) + self.engine[model_name].allocate_buffers(shape_dict=alloc_shape, device=self.device) + + def loadEngines( + self, + engine_dir, + framework_model_dir, + onnx_dir, + onnx_opset, + opt_batch_size, + opt_image_height, + opt_image_width, + static_batch=False, + static_shape=True, + enable_refit=False, + enable_all_tactics=False, + timing_cache=None, + ): + """ + Build and load engines for TensorRT accelerated inference. + Export ONNX models first, if applicable. + + Args: + engine_dir (str): + Directory to store the TensorRT engines. + framework_model_dir (str): + Directory to store the framework model ckpt. + onnx_dir (str): + Directory to store the ONNX models. + onnx_opset (int): + ONNX opset version to export the models. + opt_batch_size (int): + Batch size to optimize for during engine building. + opt_image_height (int): + Image height to optimize for during engine building. Must be a multiple of 8. + opt_image_width (int): + Image width to optimize for during engine building. Must be a multiple of 8. + static_batch (bool): + Build engine only for specified opt_batch_size. + static_shape (bool): + Build engine only for specified opt_image_height & opt_image_width. Default = True. + enable_refit (bool): + Build engines with refit option enabled. + enable_all_tactics (bool): + Enable all tactic sources during TensorRT engine builds. + timing_cache (str): + Path to the timing cache to speed up TensorRT build. + """ + # Create directories if missing + for directory in [engine_dir, onnx_dir]: + if not os.path.exists(directory): + print(f"[I] Create directory: {directory}") + pathlib.Path(directory).mkdir(parents=True) + + # Load pipeline models + models_args = {'version': self.version, 'pipeline': self.pipeline_type, 'device': self.device, + 'hf_token': self.hf_token, 'verbose': self.verbose, 'framework_model_dir': framework_model_dir, + 'max_batch_size': self.max_batch_size} + if 'clip-vis' in self.stages: + self.models['clip-vis'] = CLIPVisionWithProjModel(**models_args, subfolder='image_encoder') + if 'clip-imgfe' in self.stages: + self.models['clip-imgfe'] = CLIPImageProcessorModel(**models_args, subfolder='feature_extractor') + if 'unet-temp' in self.stages: + self.models['unet-temp'] = UNetTemporalModel(**models_args, fp16=True, num_frames=self.num_frames, do_classifier_free_guidance=self.do_classifier_free_guidance) + if 'vae-temp' in self.stages: + self.models['vae-temp'] = VAEDecTemporalModel(**models_args, decode_chunk_size=self.decode_chunk_size) + self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor) + + # Configure pipeline models to load + model_names = self.models.keys() + self.torch_fallback = dict(zip(model_names, [self.torch_inference or self.config.get(model_name.replace('-','_')+'_torch_fallback', False) for model_name in model_names])) + onnx_path = dict(zip(model_names, [self.getOnnxPath(model_name, onnx_dir, opt=False) for model_name in model_names])) + onnx_opt_path = dict(zip(model_names, [self.getOnnxPath(model_name, onnx_dir) for model_name in model_names])) + engine_path = dict(zip(model_names, [self.getEnginePath(model_name, engine_dir) for model_name in model_names])) + do_engine_refit = dict(zip(model_names, [enable_refit and model_name.startswith('unet') for model_name in model_names])) + + # Export models to ONNX + for model_name, obj in self.models.items(): + if self.torch_fallback[model_name]: + continue + do_export_onnx = not os.path.exists(engine_path[model_name]) and not os.path.exists(onnx_opt_path[model_name]) + if do_export_onnx: + obj.export_onnx(onnx_path[model_name], onnx_opt_path[model_name], onnx_opset, opt_image_height, opt_image_width) + + # Build TensorRT engines + for model_name, obj in self.models.items(): + if self.torch_fallback[model_name]: + continue + engine = Engine(engine_path[model_name]) + if not os.path.exists(engine_path[model_name]): + update_output_names = obj.get_output_names() + obj.extra_output_names if obj.extra_output_names else None + engine.build(onnx_opt_path[model_name], + fp16=True, + input_profile=obj.get_input_profile( + opt_batch_size, opt_image_height, opt_image_width, + static_batch=static_batch, static_shape=static_shape + ), + enable_refit=do_engine_refit[model_name], + enable_all_tactics=enable_all_tactics, + timing_cache=timing_cache, + update_output_names=update_output_names, + native_instancenorm=False) + self.engine[model_name] = engine + + # Load TensorRT engines + for model_name in self.models.keys(): + if not self.torch_fallback[model_name]: + self.engine[model_name].load() + + def activateEngines(self, model_name, alloc_shape=None): + if not self.torch_fallback[model_name]: + device_memory_update = self.low_vram and not self.shared_device_memory + if device_memory_update: + assert not self.use_cuda_graph + # Reclaim GPU memory from torch cache + torch.cuda.empty_cache() + self.shared_device_memory = cudart.cudaMalloc(self.max_shared_device_memory_size)[1] + # Create TensorRT execution context + if not self.engine[model_name].context: + assert not self.use_cuda_graph + self.engine[model_name].activate(device_memory=self.shared_device_memory) + if device_memory_update: + self.engine[model_name].reactivate(device_memory=self.shared_device_memory) + if alloc_shape and not self.engine[model_name].tensors: + assert not self.use_cuda_graph + self.engine[model_name].allocate_buffers(shape_dict=alloc_shape, device=self.device) + else: + # Load torch model + if not model_name in self.torch_models: + self.torch_models[model_name] = self.models[model_name].get_model(torch_inference=self.torch_inference) + + def deactivateEngines(self, model_name, release_model=True): + if not release_model: + return + if not self.torch_fallback[model_name]: + assert not self.use_cuda_graph + self.engine[model_name].deallocate_buffers() + self.engine[model_name].deactivate() + # Shared device memory deallocated only in low VRAM mode + if self.low_vram and self.shared_device_memory: + cudart.cudaFree(self.shared_device_memory) + self.shared_device_memory = None + else: + del self.torch_models[model_name] + + def print_summary(self, denoising_steps, walltime_ms, batch_size, num_frames): + print('|-----------------|--------------|') + print('| {:^15} | {:^12} |'.format('Module', 'Latency')) + print('|-----------------|--------------|') + print('| {:^15} | {:>9.2f} ms |'.format('VAE-Enc', cudart.cudaEventElapsedTime(self.events['vae_encoder'][0], self.events['vae_encoder'][1])[1])) + print('| {:^15} | {:>9.2f} ms |'.format('CLIP', cudart.cudaEventElapsedTime(self.events['clip'][0], self.events['clip'][1])[1])) + print('| {:^15} | {:>9.2f} ms |'.format('UNet'+('+CNet' if self.pipeline_type.is_controlnet() else '')+' x '+str(denoising_steps), cudart.cudaEventElapsedTime(self.events['denoise'][0], self.events['denoise'][1])[1])) + print('| {:^15} | {:>9.2f} ms |'.format('VAE-Dec', cudart.cudaEventElapsedTime(self.events['vae'][0], self.events['vae'][1])[1])) + print('|-----------------|--------------|') + print('| {:^15} | {:>9.2f} ms |'.format('Pipeline', walltime_ms)) + print('|-----------------|--------------|') + print('Throughput: {:.2f} videos/min ({} frames)'.format(batch_size*60000./walltime_ms, num_frames)) + + def save_video(self, frames, pipeline, seed): + video_name_prefix = '-'.join([pipeline, 'fp16', str(seed), str(random.randint(1000,9999))]) + video_name_suffix = 'torch' if self.torch_inference else 'trt' + video_path = video_name_prefix+'-'+video_name_suffix+'.gif' + print(f"Saving video to: {video_path}") + frames[0].save(os.path.join(self.output_dir, video_path), save_all=True,optimize=False, append_images=frames[1:], loop=0) + + def _encode_image(self, image, num_videos_per_prompt, do_classifier_free_guidance): + dtype = next(self.torch_models['clip-vis'].parameters()).dtype + + if not isinstance(image, torch.Tensor): + image = self.image_processor.pil_to_numpy(image) + image = self.image_processor.numpy_to_pt(image) + + # We normalize the image before resizing to match with the original implementation. + # Then we unnormalize it after resizing. + image = image * 2.0 - 1.0 + image = _resize_with_antialiasing(image, (224, 224)) + image = (image + 1.0) / 2.0 + + # Normalize the image with for CLIP input + image = self.torch_models['clip-imgfe']( + images=image, + do_normalize=True, + do_center_crop=False, + do_resize=False, + do_rescale=False, + return_tensors="pt", + ).pixel_values + + image = image.to(device=self.device, dtype=dtype) + image_embeddings = self.torch_models['clip-vis'](image).image_embeds + image_embeddings = image_embeddings.unsqueeze(1) + + # duplicate image embeddings for each generation per prompt, using mps friendly method + bs_embed, seq_len, _ = image_embeddings.shape + image_embeddings = image_embeddings.repeat(1, num_videos_per_prompt, 1) + image_embeddings = image_embeddings.view(bs_embed * num_videos_per_prompt, seq_len, -1) + + if do_classifier_free_guidance: + negative_image_embeddings = torch.zeros_like(image_embeddings) + + # For classifier free guidance, we need to do two forward passes. + # Here we concatenate the unconditional and text embeddings into a single batch + # to avoid doing two forward passes + image_embeddings = torch.cat([negative_image_embeddings, image_embeddings]) + + return image_embeddings + + def _encode_vae_image( + self, + image: torch.Tensor, + device, + num_videos_per_prompt, + do_classifier_free_guidance, + ): + image = image.to(device=device) + image_latents = self.torch_models['vae-temp'].encode(image).latent_dist.mode() + + if do_classifier_free_guidance: + negative_image_latents = torch.zeros_like(image_latents) + + # For classifier free guidance, we need to do two forward passes. + # Here we concatenate the unconditional and text embeddings into a single batch + # to avoid doing two forward passes + image_latents = torch.cat([negative_image_latents, image_latents]) + + # duplicate image_latents for each generation per prompt, using mps friendly method + image_latents = image_latents.repeat(num_videos_per_prompt, 1, 1, 1) + + return image_latents + + def _get_add_time_ids( + self, + fps, + motion_bucket_id, + noise_aug_strength, + dtype, + batch_size, + num_videos_per_prompt, + do_classifier_free_guidance, + ): + add_time_ids = [fps, motion_bucket_id, noise_aug_strength] + add_time_ids = torch.tensor([add_time_ids], dtype=dtype) + add_time_ids = add_time_ids.repeat(batch_size * num_videos_per_prompt, 1) + + if do_classifier_free_guidance: + add_time_ids = torch.cat([add_time_ids, add_time_ids]) + + return add_time_ids + + def prepare_latents( + self, + batch_size, + num_frames, + num_channels_latents, + height, + width, + dtype, + device, + latents=None, + ): + shape = ( + batch_size, + num_frames, + num_channels_latents // 2, + height // self.vae_scale_factor, + width // self.vae_scale_factor, + ) + + if latents is None: + latents = randn_tensor(shape, generator=self.generator, device=device, dtype=dtype) + else: + latents = latents.to(device) + + # scale the initial noise by the standard deviation required by the scheduler + latents = latents * self.scheduler.init_noise_sigma + return latents + + def decode_latents(self, latents, num_frames, decode_chunk_size): + # [batch, frames, channels, height, width] -> [batch*frames, channels, height, width] + latents = latents.flatten(0, 1) + + latents = 1 / self.scaling_factor * latents + + # decode decode_chunk_size frames at a time to avoid OOM + frames = [] + for i in range(0, latents.shape[0], decode_chunk_size): + num_frames_in = latents[i : i + decode_chunk_size].shape[0] + # TODO only pass num_frames_in if it's expected + if self.torch_fallback['vae-temp']: + frame = self.torch_models['vae-temp'].decode(latents[i : i + decode_chunk_size], num_frames=num_frames_in).sample + else: + params = { + 'latent': latents[i : i + decode_chunk_size], + # FIXME segfault + #'num_frames_in': torch.Tensor([num_frames_in]).to(device=latents.device, dtype=torch.int64), + } + frame = self.runEngine('vae-temp', params)['frames'] + frames.append(frame) + frames = torch.cat(frames, dim=0) + + # [batch*frames, channels, height, width] -> [batch, channels, frames, height, width] + frames = frames.reshape(-1, num_frames, *frames.shape[1:]).permute(0, 2, 1, 3, 4) + + # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16 + frames = frames.float() + return frames + + def infer( + self, + input_image, + image_height: int, + image_width: int, + fps: int = 7, + motion_bucket_id: int = 127, + noise_aug_strength: int = 0.02, + num_videos_per_prompt: Optional[int] = 1, + warmup: bool = False, + save_video: bool = True, + ): + """ + Run the video diffusion pipeline. + + Args: + input_image (image): + Input image used to initialize the latents or to be inpainted. + image_height (int): + Height (in pixels) of the image to be generated. Must be a multiple of 8. + image_width (int): + Width (in pixels) of the image to be generated. Must be a multiple of 8. + fps (`int`, *optional*, defaults to 7): + Frames per second. The rate at which the generated images shall be exported to a video after generation. + Note that Stable Diffusion Video's UNet was micro-conditioned on fps-1 during training. + motion_bucket_id (`int`, *optional*, defaults to 127): + The motion bucket ID. Used as conditioning for the generation. The higher the number the more motion will be in the video. + noise_aug_strength (`int`, *optional*, defaults to 0.02): + The amount of noise added to the init image, the higher it is the less the video will look like the init image. Increase it for more motion. + num_videos_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + warmup (bool): + Indicate if this is a warmup run. + save_video (bool): + Save the video image. + """ + + if self.generator and self.seed: + self.generator.manual_seed(self.seed) + + # TODO + batch_size = 1 + # Fast warmup + denoising_steps = 1 if warmup else self.denoising_steps + + torch.cuda.synchronize() + e2e_tic = time.perf_counter() + + class LoadModelContext: + def __init__(ctx, model_name, alloc_shape=None, release_model=False): + ctx.model_name = model_name + ctx.release_model = release_model + ctx.alloc_shape = alloc_shape + def __enter__(ctx): + self.activateEngines(ctx.model_name, alloc_shape=ctx.alloc_shape) + def __exit__(ctx, exc_type, exc_val, exc_tb): + self.deactivateEngines(ctx.model_name, release_model=ctx.release_model) + + # Release model opportunistically in TensorRT pipeline only in low VRAM mode + release_model = self.low_vram and not self.torch_inference + with torch.inference_mode(), torch.autocast("cuda"), trt.Runtime(TRT_LOGGER): + with LoadModelContext('clip-imgfe', release_model=release_model), LoadModelContext('clip-vis', release_model=release_model): + self.profile_start('clip', color='green') + image_embeddings = self._encode_image(input_image, num_videos_per_prompt, self.do_classifier_free_guidance) + self.profile_stop('clip') + # NOTE Stable Diffusion Video was conditioned on fps - 1 + fps = fps - 1 + + self.profile_start('preprocess', color='pink') + input_image = self.image_processor.preprocess(input_image, height=image_height, width=image_width).to(self.device) + noise = randn_tensor(input_image.shape, generator=self.generator, device=input_image.device, dtype=input_image.dtype) + input_image = input_image + noise_aug_strength * noise + self.profile_stop('preprocess') + + # TODO + # assert self.torch_models['vae-temp'].dtype == torch.float32 + + with LoadModelContext('vae-temp'): + self.profile_start('vae_encoder', color='red') + image_latents = self._encode_vae_image(input_image, self.device, num_videos_per_prompt, self.do_classifier_free_guidance) + image_latents = image_latents.to(image_embeddings.dtype) + self.profile_stop('vae_encoder') + + # Repeat the image latents for each frame so we can concatenate them with the noise + # image_latents [batch, channels, height, width] ->[batch, num_frames, channels, height, width] + image_latents = image_latents.unsqueeze(1).repeat(1, self.num_frames, 1, 1, 1) + + # Get Added Time IDs + added_time_ids = self._get_add_time_ids( + fps, + motion_bucket_id, + noise_aug_strength, + image_embeddings.dtype, + batch_size, + num_videos_per_prompt, + self.do_classifier_free_guidance, + ) + added_time_ids = added_time_ids.to(self.device) + + # Prepare timesteps + self.scheduler.set_timesteps(denoising_steps, device=self.device) + timesteps = self.scheduler.timesteps + + # Prepare latent variables + latents = self.prepare_latents( + batch_size * num_videos_per_prompt, + self.num_frames, + 8, # TODO: num_channels_latents = unet.config.in_channels + image_height, + image_width, + image_embeddings.dtype, + input_image.device, + None, # pre-generated latents + ) + + # Prepare guidance scale + guidance_scale = torch.linspace(self.min_guidance_scale, self.max_guidance_scale, self.num_frames).unsqueeze(0) + guidance_scale = guidance_scale.to(self.device, latents.dtype) + guidance_scale = guidance_scale.repeat(batch_size * num_videos_per_prompt, 1) + guidance_scale = _append_dims(guidance_scale, latents.ndim) + + # Denoising loop + num_warmup_steps = len(timesteps) - denoising_steps * self.scheduler.order + unet_shape_dict = self.models['unet-temp'].get_shape_dict(batch_size, image_height, image_width) + with LoadModelContext('unet-temp', alloc_shape=unet_shape_dict, release_model=release_model), tqdm(total=denoising_steps) as progress_bar: + self.profile_start('denoise', color='blue') + for i, t in enumerate(timesteps): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([latents] * 2) if self.do_classifier_free_guidance else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + # Concatenate image_latents over channels dimention + latent_model_input = torch.cat([latent_model_input, image_latents], dim=2) + + # predict the noise residual + if self.torch_fallback['unet-temp']: + noise_pred = self.torch_models['unet-temp']( + latent_model_input, + t, + encoder_hidden_states=image_embeddings, + added_time_ids=added_time_ids, + return_dict=False, + )[0] + else: + params = { + "sample": latent_model_input, + "timestep": t, + "encoder_hidden_states": image_embeddings, + "added_time_ids": added_time_ids, + } + noise_pred = self.runEngine('unet-temp', params)['latent'] + + # perform guidance + if self.do_classifier_free_guidance: + noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_cond - noise_pred_uncond) + + # compute the previous noisy sample x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents).prev_sample + + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + self.profile_stop('denoise') + + with torch.inference_mode(), trt.Runtime(TRT_LOGGER), LoadModelContext('vae-temp'): + self.profile_start('vae', color='red') + self.torch_models['vae-temp'].to(dtype=torch.float16) + frames = self.decode_latents(latents, self.num_frames, self.decode_chunk_size) + frames = tensor2vid(frames, self.image_processor, output_type='pil') + self.profile_stop('vae') + + torch.cuda.synchronize() + + if warmup: + return + + e2e_toc = time.perf_counter() + walltime_ms = (e2e_toc - e2e_tic) * 1000. + self.print_summary(denoising_steps, walltime_ms, batch_size, len(frames[0])) + if save_video: + self.save_video(frames[0], self.pipeline_type.name.lower(), self.seed) + + return frames, walltime_ms + + def run(self, input_image, height, width, batch_size, batch_count, num_warmup_runs, use_cuda_graph, **kwargs): + num_warmup_runs = max(1, num_warmup_runs) if use_cuda_graph else num_warmup_runs + if num_warmup_runs > 0: + print("[I] Warming up ..") + for _ in range(num_warmup_runs): + self.infer(input_image, height, width, warmup=True) + + for _ in range(batch_count): + print("[I] Running StableDiffusion pipeline") + if self.nvtx_profile: + cudart.cudaProfilerStart() + self.infer(input_image, height, width, warmup=False) + if self.nvtx_profile: + cudart.cudaProfilerStop() diff --git a/demo/Diffusion/utilities.py b/demo/Diffusion/utilities.py index 11f368079..6dece14f4 100644 --- a/demo/Diffusion/utilities.py +++ b/demo/Diffusion/utilities.py @@ -1,4 +1,5 @@ # +# Copyright (c) Alibaba, Inc. and its affiliates. # SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # @@ -46,6 +47,9 @@ TRT_LOGGER = trt.Logger(trt.Logger.ERROR) +def GiB(val): + return val * 1 << 30 + # Map of numpy dtype -> torch dtype numpy_to_torch_dtype_dict = { np.uint8 : torch.uint8, @@ -151,6 +155,7 @@ def CUASSERT(cuda_ret): class PIPELINE_TYPE(Enum): TXT2IMG = auto() IMG2IMG = auto() + IMG2VID = auto() INPAINT = auto() CONTROLNET = auto() XL_BASE = auto() @@ -162,6 +167,9 @@ def is_txt2img(self): def is_img2img(self): return self == self.IMG2IMG + def is_img2vid(self): + return self == self.IMG2VID + def is_inpaint(self): return self == self.INPAINT @@ -236,6 +244,7 @@ def build(self, enable_all_tactics=False, timing_cache=None, update_output_names=None, + native_instancenorm=True, verbose=False, **extra_build_args ): @@ -249,7 +258,10 @@ def build(self, if not enable_all_tactics: extra_build_args['tactic_sources'] = [] - network = network_from_onnx_path(onnx_path, flags=[trt.OnnxParserFlag.NATIVE_INSTANCENORM]) + flags = [] + if native_instancenorm: + flags.append(trt.OnnxParserFlag.NATIVE_INSTANCENORM) + network = network_from_onnx_path(onnx_path, flags=flags) if update_output_names: print(f"Updating network outputs to {update_output_names}") network = ModifyNetworkOutputs(network, update_output_names) @@ -272,13 +284,21 @@ def load(self): print(f"Loading TensorRT engine: {self.engine_path}") self.engine = engine_from_bytes(bytes_from_path(self.engine_path)) - def activate(self, reuse_device_memory=None): - if reuse_device_memory: + def activate(self, device_memory=None): + if device_memory: self.context = self.engine.create_execution_context_without_device_memory() - self.context.device_memory = reuse_device_memory + self.context.device_memory = device_memory else: self.context = self.engine.create_execution_context() + def reactivate(self, device_memory): + assert self.context + self.context.device_memory = device_memory + + def deactivate(self): + del self.context + self.context = None + def allocate_buffers(self, shape_dict=None, device='cuda'): for binding in range(self.engine.num_io_tensors): name = self.engine.get_tensor_name(binding) @@ -293,8 +313,12 @@ def allocate_buffers(self, shape_dict=None, device='cuda'): self.tensors[name] = tensor - def infer(self, feed_dict, stream, use_cuda_graph=False): + def deallocate_buffers(self): + for idx in range(self.engine.num_io_tensors): + binding = self.engine[idx] + del self.tensors[binding] + def infer(self, feed_dict, stream, use_cuda_graph=False): for name, buf in feed_dict.items(): self.tensors[name].copy_(buf) @@ -322,13 +346,13 @@ def infer(self, feed_dict, stream, use_cuda_graph=False): return self.tensors -def save_image(images, image_path_dir, image_name_prefix): +def save_image(images, image_path_dir, image_name_prefix, image_name_suffix): """ Save the generated images to png files. """ images = ((images + 1) * 255 / 2).clamp(0, 255).detach().permute(0, 2, 3, 1).round().type(torch.uint8).cpu().numpy() for i in range(images.shape[0]): - image_path = os.path.join(image_path_dir, image_name_prefix+str(i+1)+'-'+str(random.randint(1000,9999))+'.png') + image_path = os.path.join(image_path_dir, image_name_prefix+str(i+1)+'-'+str(random.randint(1000,9999))+'-'+image_name_suffix+'.png') print(f"Saving image {i+1} / {images.shape[0]} to: {image_path}") Image.fromarray(images[i]).save(image_path) @@ -344,6 +368,137 @@ def preprocess_image(image): image = torch.from_numpy(image).contiguous() return 2.0 * image - 1.0 +# Taken from https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_video_diffusion/pipeline_stable_video_diffusion.py#L620 +def _resize_with_antialiasing(input, size, interpolation="bicubic", align_corners=True): + h, w = input.shape[-2:] + factors = (h / size[0], w / size[1]) + + # First, we have to determine sigma + # Taken from skimage: https://github.com/scikit-image/scikit-image/blob/v0.19.2/skimage/transform/_warps.py#L171 + sigmas = ( + max((factors[0] - 1.0) / 2.0, 0.001), + max((factors[1] - 1.0) / 2.0, 0.001), + ) + + # Now kernel size. Good results are for 3 sigma, but that is kind of slow. Pillow uses 1 sigma + # https://github.com/python-pillow/Pillow/blob/master/src/libImaging/Resample.c#L206 + # But they do it in the 2 passes, which gives better results. Let's try 2 sigmas for now + ks = int(max(2.0 * 2 * sigmas[0], 3)), int(max(2.0 * 2 * sigmas[1], 3)) + + # Make sure it is odd + if (ks[0] % 2) == 0: + ks = ks[0] + 1, ks[1] + + if (ks[1] % 2) == 0: + ks = ks[0], ks[1] + 1 + + input = _gaussian_blur2d(input, ks, sigmas) + + output = torch.nn.functional.interpolate(input, size=size, mode=interpolation, align_corners=align_corners) + return output + + +def _compute_padding(kernel_size): + """Compute padding tuple.""" + # 4 or 6 ints: (padding_left, padding_right,padding_top,padding_bottom) + # https://pytorch.org/docs/stable/nn.html#torch.nn.functional.pad + if len(kernel_size) < 2: + raise AssertionError(kernel_size) + computed = [k - 1 for k in kernel_size] + + # for even kernels we need to do asymmetric padding :( + out_padding = 2 * len(kernel_size) * [0] + + for i in range(len(kernel_size)): + computed_tmp = computed[-(i + 1)] + + pad_front = computed_tmp // 2 + pad_rear = computed_tmp - pad_front + + out_padding[2 * i + 0] = pad_front + out_padding[2 * i + 1] = pad_rear + + return out_padding + + +def _filter2d(input, kernel): + # prepare kernel + b, c, h, w = input.shape + tmp_kernel = kernel[:, None, ...].to(device=input.device, dtype=input.dtype) + + tmp_kernel = tmp_kernel.expand(-1, c, -1, -1) + + height, width = tmp_kernel.shape[-2:] + + padding_shape: list[int] = _compute_padding([height, width]) + input = torch.nn.functional.pad(input, padding_shape, mode="reflect") + + # kernel and input tensor reshape to align element-wise or batch-wise params + tmp_kernel = tmp_kernel.reshape(-1, 1, height, width) + input = input.view(-1, tmp_kernel.size(0), input.size(-2), input.size(-1)) + + # convolve the tensor with the kernel. + output = torch.nn.functional.conv2d(input, tmp_kernel, groups=tmp_kernel.size(0), padding=0, stride=1) + + out = output.view(b, c, h, w) + return out + + +def _gaussian(window_size: int, sigma): + if isinstance(sigma, float): + sigma = torch.tensor([[sigma]]) + + batch_size = sigma.shape[0] + + x = (torch.arange(window_size, device=sigma.device, dtype=sigma.dtype) - window_size // 2).expand(batch_size, -1) + + if window_size % 2 == 0: + x = x + 0.5 + + gauss = torch.exp(-x.pow(2.0) / (2 * sigma.pow(2.0))) + + return gauss / gauss.sum(-1, keepdim=True) + + +def _gaussian_blur2d(input, kernel_size, sigma): + if isinstance(sigma, tuple): + sigma = torch.tensor([sigma], dtype=input.dtype) + else: + sigma = sigma.to(dtype=input.dtype) + + ky, kx = int(kernel_size[0]), int(kernel_size[1]) + bs = sigma.shape[0] + kernel_x = _gaussian(kx, sigma[:, 1].view(bs, 1)) + kernel_y = _gaussian(ky, sigma[:, 0].view(bs, 1)) + out_x = _filter2d(input, kernel_x[..., None, :]) + out = _filter2d(out_x, kernel_y[..., None]) + + return out + +def _append_dims(x, target_dims): + """Appends dimensions to the end of a tensor until it has target_dims dimensions.""" + dims_to_append = target_dims - x.ndim + if dims_to_append < 0: + raise ValueError(f"input has {x.ndim} dims but target_dims is {target_dims}, which is less") + return x[(...,) + (None,) * dims_to_append] + +# Not a contribution +# Changes made by NVIDIA CORPORATION & AFFILIATES enabling tensor2vid or otherwise documented as +# NVIDIA-proprietary are not a contribution and subject to the terms and conditions at the top of the file +def tensor2vid(video: torch.Tensor, processor, output_type="np"): + # Based on: + # https://github.com/modelscope/modelscope/blob/1509fdb973e5871f37148a4b5e5964cafd43e64d/modelscope/pipelines/multi_modal/text_to_video_synthesis_pipeline.py#L78 + + batch_size, channels, num_frames, height, width = video.shape + outputs = [] + for batch_idx in range(batch_size): + batch_vid = video[batch_idx].permute(1, 0, 2, 3) + batch_output = processor.postprocess(batch_vid, output_type) + + outputs.append(batch_output) + + return outputs + def prepare_mask_and_masked_image(image, mask): """ image: PIL.Image.Image @@ -509,7 +664,6 @@ def process_pipeline_args(args): 'timing_cache': args.timing_cache, 'int8': args.int8, 'quantization_level': args.quantization_level, - 'denoising_steps': args.denoising_steps, } args_run_demo = (args.prompt, args.negative_prompt, args.height, args.width, args.batch_size, args.batch_count, args.num_warmup_runs, args.use_cuda_graph) diff --git a/demo/Diffusion/utils_sd3/mmdit.py b/demo/Diffusion/utils_sd3/mmdit.py index c346b483b..2fe322636 100644 --- a/demo/Diffusion/utils_sd3/mmdit.py +++ b/demo/Diffusion/utils_sd3/mmdit.py @@ -511,7 +511,6 @@ def __init__( device = None, ): super().__init__() - print(f"mmdit initializing with: {input_size=}, {patch_size=}, {in_channels=}, {depth=}, {mlp_ratio=}, {learn_sigma=}, {adm_in_channels=}, {context_embedder_config=}, {register_length=}, {attn_mode=}, {rmsnorm=}, {scale_mod_only=}, {swiglu=}, {out_channels=}, {pos_embed_scaling_factor=}, {pos_embed_offset=}, {pos_embed_max_size=}, {num_patches=}, {qk_norm=}, {qkv_bias=}, {dtype=}, {device=}") self.dtype = dtype self.learn_sigma = learn_sigma self.in_channels = in_channels diff --git a/docker/rockylinux8.Dockerfile b/docker/rockylinux8.Dockerfile index 1ff359e2d..2ad1caf95 100644 --- a/docker/rockylinux8.Dockerfile +++ b/docker/rockylinux8.Dockerfile @@ -25,7 +25,7 @@ ENV NV_CUDNN_VERSION 8.9.6.50-1 ENV NV_CUDNN_PACKAGE libcudnn8-${NV_CUDNN_VERSION}.cuda12.2 ENV NV_CUDNN_PACKAGE_DEV libcudnn8-devel-${NV_CUDNN_VERSION}.cuda12.2 -ENV TRT_VERSION 10.2.0.19 +ENV TRT_VERSION 10.3.0.26 SHELL ["/bin/bash", "-c"] RUN dnf install -y \ @@ -62,15 +62,15 @@ RUN dnf install -y python38 python38-devel &&\ # Install TensorRT RUN if [ "${CUDA_VERSION:0:2}" = "11" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib64 \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp38-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib64 \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp38-none-linux_x86_64.whl ;\ elif [ "${CUDA_VERSION:0:2}" = "12" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib64 \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp38-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib64 \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp38-none-linux_x86_64.whl ;\ else \ echo "Invalid CUDA_VERSION"; \ exit 1; \ diff --git a/docker/rockylinux9.Dockerfile b/docker/rockylinux9.Dockerfile index 815b608e1..8741977bc 100644 --- a/docker/rockylinux9.Dockerfile +++ b/docker/rockylinux9.Dockerfile @@ -25,7 +25,7 @@ ENV NV_CUDNN_VERSION 8.9.6.50-1 ENV NV_CUDNN_PACKAGE libcudnn8-${NV_CUDNN_VERSION}.cuda12.2 ENV NV_CUDNN_PACKAGE_DEV libcudnn8-devel-${NV_CUDNN_VERSION}.cuda12.2 -ENV TRT_VERSION 10.2.0.19 +ENV TRT_VERSION 10.3.0.26 SHELL ["/bin/bash", "-c"] RUN dnf install -y \ @@ -67,15 +67,15 @@ RUN dnf -y install \ # Install TensorRT RUN if [ "${CUDA_VERSION:0:2}" = "11" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib64 \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp39-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib64 \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp39-none-linux_x86_64.whl ;\ elif [ "${CUDA_VERSION:0:2}" = "12" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib64 \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp39-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib64 \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp39-none-linux_x86_64.whl ;\ else \ echo "Invalid CUDA_VERSION"; \ exit 1; \ diff --git a/docker/ubuntu-20.04.Dockerfile b/docker/ubuntu-20.04.Dockerfile index 881139e3a..b481d945d 100644 --- a/docker/ubuntu-20.04.Dockerfile +++ b/docker/ubuntu-20.04.Dockerfile @@ -28,7 +28,7 @@ ENV CUDA_VERSION_MAJOR_MINOR=12.2 ENV NV_CUDNN_PACKAGE "libcudnn8=$NV_CUDNN_VERSION-1+cuda${CUDA_VERSION_MAJOR_MINOR}" ENV NV_CUDNN_PACKAGE_DEV "libcudnn8-dev=$NV_CUDNN_VERSION-1+cuda${CUDA_VERSION_MAJOR_MINOR}" -ENV TRT_VERSION 10.2.0.19 +ENV TRT_VERSION 10.3.0.26 SHELL ["/bin/bash", "-c"] RUN apt-get update && apt-get install -y --no-install-recommends \ @@ -84,15 +84,15 @@ RUN apt-get install -y --no-install-recommends \ # Install TensorRT RUN if [ "${CUDA_VERSION:0:2}" = "11" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib/x86_64-linux-gnu \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp38-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib/x86_64-linux-gnu \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp38-none-linux_x86_64.whl ;\ elif [ "${CUDA_VERSION:0:2}" = "12" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib/x86_64-linux-gnu \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp38-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib/x86_64-linux-gnu \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp38-none-linux_x86_64.whl ;\ else \ echo "Invalid CUDA_VERSION"; \ exit 1; \ diff --git a/docker/ubuntu-22.04-aarch64.Dockerfile b/docker/ubuntu-22.04-aarch64.Dockerfile index 783193d24..e6991c4cc 100644 --- a/docker/ubuntu-22.04-aarch64.Dockerfile +++ b/docker/ubuntu-22.04-aarch64.Dockerfile @@ -20,7 +20,7 @@ ARG CUDA_VERSION=12.5.0 # Multi-arch container support available in non-cudnn containers. FROM nvidia/cuda:${CUDA_VERSION}-devel-ubuntu22.04 -ENV TRT_VERSION 10.2.0.19 +ENV TRT_VERSION 10.3.0.26 SHELL ["/bin/bash", "-c"] # Setup user account diff --git a/docker/ubuntu-22.04.Dockerfile b/docker/ubuntu-22.04.Dockerfile index 924f3c02d..43f872a68 100644 --- a/docker/ubuntu-22.04.Dockerfile +++ b/docker/ubuntu-22.04.Dockerfile @@ -28,7 +28,7 @@ ENV CUDA_VERSION_MAJOR_MINOR=12.2 ENV NV_CUDNN_PACKAGE "libcudnn8=$NV_CUDNN_VERSION-1+cuda${CUDA_VERSION_MAJOR_MINOR}" ENV NV_CUDNN_PACKAGE_DEV "libcudnn8-dev=$NV_CUDNN_VERSION-1+cuda${CUDA_VERSION_MAJOR_MINOR}" -ENV TRT_VERSION 10.2.0.19 +ENV TRT_VERSION 10.3.0.26 SHELL ["/bin/bash", "-c"] RUN apt-get update && apt-get install -y --no-install-recommends \ @@ -84,15 +84,15 @@ RUN apt-get install -y --no-install-recommends \ # Install TensorRT RUN if [ "${CUDA_VERSION:0:2}" = "11" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-11.8.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib/x86_64-linux-gnu \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp310-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-11.8.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib/x86_64-linux-gnu \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp310-none-linux_x86_64.whl ;\ elif [ "${CUDA_VERSION:0:2}" = "12" ]; then \ - wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.2.0/tars/TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && tar -xf TensorRT-10.2.0.19.Linux.x86_64-gnu.cuda-12.5.tar.gz \ - && cp -a TensorRT-10.2.0.19/lib/*.so* /usr/lib/x86_64-linux-gnu \ - && pip install TensorRT-10.2.0.19/python/tensorrt-10.2.0-cp310-none-linux_x86_64.whl ;\ + wget https://developer.nvidia.com/downloads/compute/machine-learning/tensorrt/10.3.0/tars/TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && tar -xf TensorRT-10.3.0.26.Linux.x86_64-gnu.cuda-12.5.tar.gz \ + && cp -a TensorRT-10.3.0.26/lib/*.so* /usr/lib/x86_64-linux-gnu \ + && pip install TensorRT-10.3.0.26/python/tensorrt-10.3.0-cp310-none-linux_x86_64.whl ;\ else \ echo "Invalid CUDA_VERSION"; \ exit 1; \ diff --git a/docker/ubuntu-cross-aarch64.Dockerfile b/docker/ubuntu-cross-aarch64.Dockerfile index 253dd0421..6a03c874c 100644 --- a/docker/ubuntu-cross-aarch64.Dockerfile +++ b/docker/ubuntu-cross-aarch64.Dockerfile @@ -21,7 +21,7 @@ ARG OS_VERSION=22.04 FROM nvidia/cuda:${CUDA_VERSION}-devel-ubuntu${OS_VERSION} LABEL maintainer="NVIDIA CORPORATION" -ENV TRT_VERSION 10.2.0.19 +ENV TRT_VERSION 10.3.0.26 ENV DEBIAN_FRONTEND=noninteractive ARG uid=1000 diff --git a/include/NvInfer.h b/include/NvInfer.h index 11c6994f3..fc8d4ec81 100644 --- a/include/NvInfer.h +++ b/include/NvInfer.h @@ -102,7 +102,7 @@ enum class LayerType : int32_t kNMS = 43, //!< NMS layer kREVERSE_SEQUENCE = 44, //!< Reverse sequence layer kNORMALIZATION = 45, //!< Normalization layer - kPLUGIN_V3 = 46 //!< PluginV3 layer. + kPLUGIN_V3 = 46, //!< PluginV3 layer. }; //! @@ -841,8 +841,8 @@ class ILayer : public INoCopy //! \code //! Shorthand: //! I = dimensions of input image. -//! B = prePadding, before the image data. For deconvolution, prePadding is set before output. -//! A = postPadding, after the image data. For deconvolution, postPadding is set after output. +//! B = prePadding, before the image data. +//! A = postPadding, after the image data. //! P = delta between input and output //! S = stride //! F = filter @@ -2202,7 +2202,6 @@ class IDeconvolutionLayer : public ILayer //! //! Default: (0, 0, ..., 0) //! - //! If executing this layer on DLA, padding must be 0. //! //! \see getPrePadding() //! @@ -2230,7 +2229,6 @@ class IDeconvolutionLayer : public ILayer //! //! Default: (0, 0, ..., 0) //! - //! If executing this layer on DLA, padding must be 0. //! //! \see getPostPadding() //! @@ -2949,8 +2947,10 @@ class IReduceLayer : public ILayer //! //! \brief Layer that represents a padding operation. //! -//! The padding layer adds zero-padding at the start and end of the input tensor. It only supports padding along the two -//! innermost dimensions. Applying negative padding results in cropping of the input. +//! The padding layer adds zero-padding at the start and end of the input tensor. It supports padding +//! only the last two dimensions. Applying negative padding results in cropping of the input. +//! +//! To pad across any subset of dimensions, use ISliceLayer with SampleMode::kFILL. //! //! \warning Do not inherit from this class, as doing so will break forward-compatibility of the API and ABI. //! @@ -3237,12 +3237,13 @@ constexpr inline int32_t EnumMax() noexcept //! //! The slice layer has two variants, static and dynamic. Static slice specifies the start, size, and stride //! dimensions at layer creation time via Dims and can use the get/set accessor functions of the ISliceLayer. -//! Dynamic slice specifies one or more of start, size or stride as ITensors, by using ILayer::setInput to add -//! a second, third, or fourth input respectively. The corresponding Dims are used if an input +//! Static slice layers can also optionally specify axes through the get/set accessor functions of the ISliceLayer. +//! Dynamic slice specifies one or more of start, size, stride, or axes as ITensors, by using ILayer::setInput to add +//! a second, third, fourth, or sixth input respectively. The corresponding Dims are used if an input //! is missing or null. //! //! An application can determine if the ISliceLayer has a dynamic output shape based on whether -//! the size input (third input) is present and non-null. +//! the size or axes input is present and non-null. //! //! The slice layer selects for each dimension a start location from within the input tensor, and //! copies elements to the output tensor using the specified stride across the input tensor. @@ -3255,18 +3256,35 @@ constexpr inline int32_t EnumMax() noexcept //! stride = {1, 2} //! output = {{1, 5}} //! +//! If axes are provided then starts, ends, and strides must have the same length as axes +//! and specifies a subset of dimensions to slice. If axes are not provided, starts, ends, and strides +//! must be of the same length as the rank of the input tensor. +//! +//! An example of using slice on a tensor with axes specified: +//! input = {{0, 2, 4}, {1, 3, 5}} +//! start = {1} +//! size = {2} +//! stride = {1} +//! axes = {1} +//! output = {{2, 4}, {3, 5}} +//! //! When the sampleMode is kCLAMP or kREFLECT, for each input dimension, if its size is 0 then the corresponding output //! dimension must be 0 too. //! +//! When the sampleMode is kFILL, the fifth input to the slice layer is used to determine the value to fill in out-of-bound +//! indices. It is an error to specify the fifth input in any other sampleMode. +//! //! A slice layer can produce a shape tensor if the following conditions are met: //! //! * start, size, and stride are build time constants, either as static Dims or as constant input tensors. +//! * axes, if provided, are build time constants, either as static Dims or as a constant input tensor. //! * The number of elements in the output tensor does not exceed 2 * Dims::MAX_DIMS. //! //! The input tensor is a shape tensor if the output is a shape tensor. //! //! The following constraints must be satisfied to execute this layer on DLA: //! * start, size, and stride are build time constants, either as static Dims or as constant input tensors. +//! * axes, if provided, are build time constants, either as static Dims or as a constant input tensor. //! * sampleMode is kSTRICT_BOUNDS. //! * Strides are 1 for all dimensions. //! * Slicing is not performed on the first dimension @@ -3401,6 +3419,10 @@ class ISliceLayer : public ILayer //! or be implicitly convertible to the input data type. //! Implicit data type conversion is supported among kFLOAT, kHALF, kINT8, and kFP8 data types. //! This input is disallowed for other modes. + //! - 5: The axes tensor indicating the corresponding axes that start, size, and stride + //! should apply to, as a 1D Int32 shape tensor. Negative values for axes + //! indicate indexing from the back of the input tensor. Values must be unique and be + //! within the interval of [-rank(input), rank(input)-1]. //! //! Using the corresponding setter resets the input to null. //! @@ -3409,6 +3431,35 @@ class ISliceLayer : public ILayer //! using ILayer::setInput; + //! + //! \brief Set the axes for this ISliceLayer. + //! + //! \param axes The axes on which the starts, ends, and strides parameters of the slice apply to. + //! + //! If a sixth input had been used to create this layer, that input is reset to null by this method. + //! + //! \see getAxes + //! + void setAxes(Dims const& axes) noexcept + { + mImpl->setAxes(axes); + } + + //! + //! \brief Get the axes for this ISliceLayer. + //! + //! \return The axes on which the starts, ends, and strides parameters of this slice apply to. + //! + //! If the sixth input is present and non-null, + //! this function returns a Dims with nbDims = -1. + //! + //! \see setAxes + //! + Dims getAxes() const noexcept + { + return mImpl->getAxes(); + } + protected: apiv::VSliceLayer* mImpl; virtual ~ISliceLayer() noexcept = default; @@ -4007,8 +4058,8 @@ struct EnumMaxImpl //! Resize layer can be used for resizing a N-D tensor. //! //! Resize layer currently supports the following configurations: -//! - InterpolationMode::kNEAREST - resizes innermost `m` dimensions of N-D, where 0 < m <= min(8, N) and N > 0 -//! - InterpolationMode::kLINEAR - resizes innermost `m` dimensions of N-D, where 0 < m <= min(3, N) and N > 0 +//! - InterpolationMode::kNEAREST - resizes last `m` dimensions of N-D, where 0 < m <= min(8, N) and N > 0 +//! - InterpolationMode::kLINEAR - resizes last `m` dimensions of N-D, where 0 < m <= min(3, N) and N > 0 //! //! Default resize mode is InterpolationMode::kNEAREST. //! @@ -5519,6 +5570,7 @@ class IDequantizeLayer : public ILayer apiv::VDequantizeLayer* mImpl; }; + //! //! \class IEinsumLayer //! @@ -7435,6 +7487,7 @@ class INetworkDefinition : public INoCopy return mImpl->addQuantizeV2(input, scale, outputType); } + //! //! \brief Add an Einsum layer to the network. //! @@ -8549,7 +8602,13 @@ enum class PreviewFeature : int32_t //! \deprecated Deprecated in TensorRT 10.0. The default value for this flag is on and can not be changed. //! kPROFILE_SHARING_0806 TRT_DEPRECATED_ENUM = 0, + + //! + //! Allows plugin I/O to be aliased when using IPluginV3OneBuildV2 + //! + kALIASED_PLUGIN_IO_10_03 = 1 }; + namespace impl { //! @@ -8560,7 +8619,7 @@ namespace impl template <> struct EnumMaxImpl { - static constexpr int32_t kVALUE = 1; + static constexpr int32_t kVALUE = 2; }; } // namespace impl diff --git a/include/NvInferImpl.h b/include/NvInferImpl.h index b77cb1823..d202c3d1f 100644 --- a/include/NvInferImpl.h +++ b/include/NvInferImpl.h @@ -703,6 +703,8 @@ class VSliceLayer : public VRoot virtual Dims getStride() const noexcept = 0; virtual void setMode(SampleMode mode) noexcept = 0; virtual SampleMode getMode() const noexcept = 0; + virtual void setAxes(Dims const& axes) noexcept = 0; + virtual Dims getAxes() const noexcept = 0; }; class VShapeLayer : public VRoot @@ -909,6 +911,7 @@ class VDequantizeLayer : public VRoot virtual void setToType(DataType toType) noexcept = 0; }; + class VScatterLayer : public VRoot { public: diff --git a/include/NvInferRuntime.h b/include/NvInferRuntime.h index 93959c372..485628a68 100644 --- a/include/NvInferRuntime.h +++ b/include/NvInferRuntime.h @@ -1093,6 +1093,54 @@ class IPluginV3OneRuntime : public IPluginCapability }; } // namespace v_1_0 +namespace v_2_0 +{ + +class IPluginV3OneBuild : public v_1_0::IPluginV3OneBuild +{ +public: + InterfaceInfo getInterfaceInfo() const noexcept override + { + return InterfaceInfo{"PLUGIN_V3ONE_BUILD", 2, 0}; + } + + //! + //! \brief Communicates to TensorRT that the output at the specified output index is aliased to the input at the + //! returned index + //! + //! Enables read-modify-write behavior in plugins. TensorRT may insert copies to facilitate this capability. + //! + //! \return An integer denoting the index of the input which is aliased to the output at outputIndex. + //! Returning -1 indicates that the output is not aliased to any input. Otherwise, the valid range for + //! return value is [0, nbInputs - 1]. + //! + //! \note A given plugin input can only be aliased to a single plugin output. + //! + //! \note This API will only be called and have an effect when PreviewFeature::kALIASED_PLUGIN_IO_10_03 is turned + //! on. + //! + //! \warning If an input is not shallow copyable, a copy inserted by TensorRT may not work as intended. Therefore, + //! using this feature with tensors requiring deep copies is not supported. + //! + //! \warning If a given tensor is requested to be aliased by two different plugins, this may result in divergent + //! copies of the tensor after writes from each plugin. e.g. In the below example, t1 and t2 could be divergent. + //! + //! +-----+ +--------+ + //! +->|Copy +--> t* ---->|Plugin0 +--> t1 + //! | +-----+ +--------+ + //! t + //! | +-----+ +--------+ + //! +->|Copy +--> t** --->|Plugin1 +--> t2 + //! +-----+ +--------+ + //! + virtual int32_t getAliasedInput(int32_t outputIndex) noexcept + { + return -1; + } +}; + +} // namespace v_2_0 + //! //! \class IPluginV3OneCore //! @@ -1128,6 +1176,15 @@ using IPluginV3OneBuild = v_1_0::IPluginV3OneBuild; //! using IPluginV3OneRuntime = v_1_0::IPluginV3OneRuntime; +//! +//! \class IPluginV3OneBuildV2 +//! +//! \brief A plugin capability interface that extends IPluginV3OneBuild by providing I/O aliasing functionality. +//! +//! \see IPluginV3OneBuild +//! +using IPluginV3OneBuildV2 = v_2_0::IPluginV3OneBuild; + namespace v_1_0 { class IPluginCreatorV3One : public IPluginCreatorInterface diff --git a/include/NvInferVersion.h b/include/NvInferVersion.h index 378acb4c2..11b9cc6df 100644 --- a/include/NvInferVersion.h +++ b/include/NvInferVersion.h @@ -24,9 +24,9 @@ #define NV_INFER_VERSION_H #define NV_TENSORRT_MAJOR 10 //!< TensorRT major version. -#define NV_TENSORRT_MINOR 2 //!< TensorRT minor version. -#define NV_TENSORRT_PATCH 0 //!< TensorRT patch version. -#define NV_TENSORRT_BUILD 19 //!< TensorRT build number. +#define NV_TENSORRT_MINOR 3 //!< TensorRT minor version. +#define NV_TENSORRT_PATCH 0 //!< TensorRT patch version. +#define NV_TENSORRT_BUILD 26 //!< TensorRT build number. #define NV_TENSORRT_LWS_MAJOR 0 //!< TensorRT LWS major version. #define NV_TENSORRT_LWS_MINOR 0 //!< TensorRT LWS minor version. diff --git a/parsers/onnx b/parsers/onnx index f161f9588..62bdde2a0 160000 --- a/parsers/onnx +++ b/parsers/onnx @@ -1 +1 @@ -Subproject commit f161f95883b4ebd8cb789de5efc67b73c0a6e694 +Subproject commit 62bdde2a04fcd53c2409cb895ee18db445b7e755 diff --git a/plugin/README.md b/plugin/README.md index 6f619095b..0416ecc0d 100644 --- a/plugin/README.md +++ b/plugin/README.md @@ -25,7 +25,8 @@ | [gridAnchorPlugin](gridAnchorPlugin) | GridAnchor_TRT | 1 | | [gridAnchorRectPlugin](gridAnchorPlugin) | GridAnchorRect_TRT | 1 | | [groupNormalizationPlugin](groupNormalizationPlugin) | GroupNormalizationPlugin | 1 | -| [instanceNormalizationPlugin](instanceNormalizationPlugin) | InstanceNormalization_TRT | 1 | +| [instanceNormalizationPlugin](instanceNormalizationPlugin) [DEPRECATED] | InstanceNormalization_TRT | 1 | +| [instanceNormalizationPlugin](instanceNormalizationPlugin) | InstanceNormalization_TRT | 2 | | [leakyReluPlugin](leakyReluPlugin) [DEPRECATED] | LReLU_TRT | 1 | | [modulatedDeformConvPlugin](modulatedDeformConvPlugin) | ModulatedDeformConv2d | 1 | | [multilevelCropAndResizePlugin](multilevelCropAndResizePlugin) | MultilevelCropAndResize_TRT | 1 | @@ -46,7 +47,8 @@ | [roiAlignPlugin](roiAlignPlugin) [DEPRECATED] | ROIAlign_TRT | 1 | | [roiAlignPlugin](roiAlignPlugin) | ROIAlign_TRT | 2 | | [resizeNearestPlugin](resizeNearestPlugin) | ResizeNearest_TRT | 1 | -| [scatterElementsPlugin](scatterElementsPlugin) | ScatterElements | 1 | +| [scatterElementsPlugin](scatterElementsPlugin) [DEPRECATED] | ScatterElements | 1 | +| [scatterElementsPlugin](scatterElementsPlugin) | ScatterElements | 2 | | [scatterPlugin](scatterPlugin) | ScatterND | 1 | | [skipLayerNormPlugin](skipLayerNormPlugin) | CustomSkipLayerNormPluginDynamic | 1, 2, 3 | | [specialSlicePlugin](specialSlicePlugin) [DEPRECATED] | SpecialSlice_TRT | 1 | diff --git a/plugin/api/inferPlugin.cpp b/plugin/api/inferPlugin.cpp index ad1ad62a2..28c42cae2 100644 --- a/plugin/api/inferPlugin.cpp +++ b/plugin/api/inferPlugin.cpp @@ -52,6 +52,7 @@ #include "roiAlignPlugin/roiAlignPlugin.h" #include "roiAlignPlugin/roiAlignPluginLegacy.h" #include "scatterElementsPlugin/scatterElementsPlugin.h" +#include "scatterElementsPlugin/scatterElementsPluginLegacy.h" #include "scatterPlugin/scatterPlugin.h" #include "specialSlicePlugin/specialSlicePlugin.h" #include "splitPlugin/split.h" @@ -221,7 +222,8 @@ extern "C" initializePlugin(logger, libNamespace); initializePlugin(logger, libNamespace); initializePlugin(logger, libNamespace); - initializePlugin(logger, libNamespace); + initializePlugin(logger, libNamespace); + initializePlugin(logger, libNamespace); initializePlugin(logger, libNamespace); initializePlugin(logger, libNamespace); initializePlugin(logger, libNamespace); diff --git a/plugin/gridAnchorPlugin/README.md b/plugin/gridAnchorPlugin/README.md index e9fc96732..7ae685011 100644 --- a/plugin/gridAnchorPlugin/README.md +++ b/plugin/gridAnchorPlugin/README.md @@ -97,4 +97,4 @@ This is the first release of this `README.md` file. ## Known issues -There are no known issues in this plugin. +There are no known issues in this plugin. \ No newline at end of file diff --git a/plugin/instanceNormalizationPlugin/README.md b/plugin/instanceNormalizationPlugin/README.md index d6d668b22..776d58cd4 100644 --- a/plugin/instanceNormalizationPlugin/README.md +++ b/plugin/instanceNormalizationPlugin/README.md @@ -13,7 +13,7 @@ The `InstanceNormalizePlugin` is used for the InstanceNormalization layer, which is generally used in deep learning models that perform image generation. This plugin is based off the [ONNX opset 6 definition](https://github.com/onnx/onnx/blob/master/docs/Operators.md#InstanceNormalization), and is used in any ONNX model that uses this operation. -Specifically, given an array of values `x = [x_0, x_1, ..., x_n]` , a scale factor, a bias factor, and an epislon, the InstanceNormalization of x is `scale * (x-mean) / sqrt(variance + epsilon) + bias` where the mean and variance are computed per instance per channel. +Specifically, given an array of values `x = [x_0, x_1, ..., x_n]` , a scale factor, a bias factor, and an epsilon, the InstanceNormalization of x is `scale * (x-mean) / sqrt(variance + epsilon) + bias` where the mean and variance are computed per instance per channel. ### Structure diff --git a/plugin/multiscaleDeformableAttnPlugin/README.md b/plugin/multiscaleDeformableAttnPlugin/README.md index 35f7796e8..4affdcca1 100644 --- a/plugin/multiscaleDeformableAttnPlugin/README.md +++ b/plugin/multiscaleDeformableAttnPlugin/README.md @@ -60,4 +60,4 @@ This is the first release of this `README.md` file. ## Known issues -There are no known issues in this plugin. \ No newline at end of file +There are no known issues in this plugin. diff --git a/plugin/nvFasterRCNN/README.md b/plugin/nvFasterRCNN/README.md index b2547a7c3..4f5a30842 100644 --- a/plugin/nvFasterRCNN/README.md +++ b/plugin/nvFasterRCNN/README.md @@ -101,4 +101,4 @@ This is the first release of this `README.md` file. ## Known issues -There are no known issues in this plugin. +There are no known issues in this plugin. \ No newline at end of file diff --git a/plugin/priorBoxPlugin/README.md b/plugin/priorBoxPlugin/README.md index ebb288850..11aa9aca9 100644 --- a/plugin/priorBoxPlugin/README.md +++ b/plugin/priorBoxPlugin/README.md @@ -95,4 +95,4 @@ This is the first release of this `README.md` file. ## Known issues -There are no known issues in this plugin. +There are no known issues in this plugin. \ No newline at end of file diff --git a/plugin/scatterElementsPlugin/README.md b/plugin/scatterElementsPlugin/README.md index 80736f34c..529bbd207 100644 --- a/plugin/scatterElementsPlugin/README.md +++ b/plugin/scatterElementsPlugin/README.md @@ -13,11 +13,12 @@ The scatterElements plugin implements the scatter operation described in (https://github.com/rusty1s/pytorch_scatter), in compliance with the [ONNX specification for ScatterElements](https://github.com/onnx/onnx/blob/main/docs/Operators.md#ScatterElements) -Note: ScatterElements with reduce="none" is implemented in TRT core, not this plugin. +Note: ScatterElements with reduce="none" is implemented in TRT core, not this plugin. ### Structure -This plugin has the plugin creator class `ScatterElementsPluginCreator` and the plugin class `ScatterElementsPlugin` which extends `IPluginV2DynamicExt`. +This plugin has the 2 versions. The latest is plugin creator class `ScatterElementsPluginV3Creator` and the plugin class `ScatterElementsPluginV3` which extends `IPluginV3`. (name: `ScatterElements`, version: 2) +The legacy plugin that will be deprecated, is plugin creator class `ScatterElementsPluginV2Creator` and the plugin class `ScatterElementsPluginV2`, which extends `IPluginV2DynamicExt` (name: `ScatterElements`, version: 1). The `ScatterElements` plugin consumes the following inputs: @@ -30,13 +31,13 @@ The `ScatterElements` plugin produces the following output: 1. `output` - T: Tensor, same shape as `data`. ## Parameters - + The `ScatterElements` plugin has the following parameters: | Type | Parameter | Description |------------------|---------------------------------|-------------------------------------------------------- |`int` |`axis` | Which axis to scatter on. Default is 0. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). -|`char` |`reduction` | Type of reduction to apply: add, mul, max, min. ‘add’: reduction using the addition operation. ‘mul’: reduction using the multiplication operation.‘max’: reduction using the maximum operation.‘min’: reduction using the minimum operation. +|`char` |`reduction` | Type of reduction to apply: add, mul, max, min. ‘add’: reduction using the addition operation. ‘mul’: reduction using the multiplication operation.‘max’: reduction using the maximum operation.‘min’: reduction using the minimum operation. The following resources provide a deeper understanding of the `scatterElements` plugin: @@ -46,12 +47,13 @@ The following resources provide a deeper understanding of the `scatterElements` ## License -For terms and conditions for use, reproduction, and distribution, see the [TensorRT Software License Agreement](https://docs.nvidia.com/deeplearning/sdk/tensorrt-sla/index.html) +For terms and conditions for use, reproduction, and distribution, see the [TensorRT Software License Agreement](https://docs.nvidia.com/deeplearning/sdk/tensorrt-sla/index.html) documentation. ## Changelog -Oct 2023: This is the first release of this `README.md` file. +- July 2024: Version 2 of the plugin migrated to `IPluginV3` interface design. The legacy plugin (version 1) using `IPluginV2DynamicExt` interface is deprecated. +- Oct 2023: This is the first release of this `README.md` file. ## Known issues diff --git a/plugin/scatterElementsPlugin/ScatterElementsPlugin_PluginConfig.yaml b/plugin/scatterElementsPlugin/ScatterElementsPlugin_PluginConfig.yaml index 7ad6e8dc4..123376776 100644 --- a/plugin/scatterElementsPlugin/ScatterElementsPlugin_PluginConfig.yaml +++ b/plugin/scatterElementsPlugin/ScatterElementsPlugin_PluginConfig.yaml @@ -17,9 +17,9 @@ --- name: ScatterElements -interface: "IPluginV2DynamicExt" +interface: "IPluginV3" versions: - "1": + "2": inputs: - data - indices @@ -60,7 +60,7 @@ versions: - "add" - "mul" - "min" - - "max" + - "max" config2: input_types: data: float16 @@ -75,7 +75,7 @@ versions: - "add" - "mul" - "min" - - "max" + - "max" config3: input_types: data: int32 @@ -90,7 +90,7 @@ versions: - "add" - "mul" - "min" - - "max" + - "max" config4: input_types: data: int64 @@ -105,7 +105,7 @@ versions: - "add" - "mul" - "min" - - "max" + - "max" config5: input_types: data: bfloat16 @@ -120,7 +120,7 @@ versions: - "add" - "mul" - "min" - - "max" + - "max" outputs: - output attributes: @@ -140,7 +140,7 @@ versions: - "add" - "mul" - "min" - - "max" + - "max" attributes_required: - reduction golden_io_path: "plugin/scatterElementsPlugin/ScatterElementsPlugin_PluginGoldenIO.json" diff --git a/plugin/scatterElementsPlugin/scatterElementsCommon.h b/plugin/scatterElementsPlugin/scatterElementsCommon.h new file mode 100644 index 000000000..a76579aca --- /dev/null +++ b/plugin/scatterElementsPlugin/scatterElementsCommon.h @@ -0,0 +1,41 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SCATTER_ELEMENTS_COMMON_H +#define SCATTER_ELEMENTS_COMMON_H + +#include +#include +#include +#include +#include + +#include "common/plugin.h" + +enum class ReductionType : int32_t +{ + kSUM, + kMUL, + kMEAN, + kMIN, + kMAX +}; + +extern std::unordered_map const kREDUCE_STR_TO_ENUM; +extern std::unordered_map const kREDUCE_ENUM_TO_STR; + +#endif // SCATTER_ELEMENTS_COMMON_H diff --git a/plugin/scatterElementsPlugin/scatterElementsPlugin.cpp b/plugin/scatterElementsPlugin/scatterElementsPlugin.cpp index babbaecc4..92e8d9e62 100644 --- a/plugin/scatterElementsPlugin/scatterElementsPlugin.cpp +++ b/plugin/scatterElementsPlugin/scatterElementsPlugin.cpp @@ -29,82 +29,95 @@ namespace nvinfer1 namespace plugin { -std::map const gReduceToEnum{ +std::unordered_map const kREDUCE_STR_TO_ENUM{ {"add", ReductionType::kSUM}, {"mean", ReductionType::kMEAN}, {"mul", ReductionType::kMUL}, {"min", ReductionType::kMIN}, {"max", ReductionType::kMAX}, }; +std::unordered_map const kREDUCE_ENUM_TO_STR{ + {ReductionType::kSUM, "add"}, + {ReductionType::kMEAN, "mean"}, + {ReductionType::kMUL, "mul"}, + {ReductionType::kMIN, "min"}, + {ReductionType::kMAX, "max"}, +}; // Static class fields initialization -PluginFieldCollection ScatterElementsPluginCreator::gFC{}; -std::vector ScatterElementsPluginCreator::gPluginAttributes; +PluginFieldCollection ScatterElementsPluginV3Creator::gFC{}; +std::vector ScatterElementsPluginV3Creator::gPluginAttributes; namespace { -constexpr char const* kSCATTER_ELEMENTS_NAME{"ScatterElements"}; -constexpr char const* kSCATTER_ELEMENTS_VERSION{"1"}; +constexpr char const* kSCATTER_PLUGIN_VERSION{"2"}; +constexpr char const* kSCATTER_PLUGIN_NAME{"ScatterElements"}; } // namespace -ScatterElementsPlugin::ScatterElementsPlugin(ReductionType reduction, int32_t dim) +ScatterElementsPluginV3::ScatterElementsPluginV3(ReductionType reduction, int32_t dim) : mReduction(reduction) , mAxis(dim) { } -ScatterElementsPlugin::ScatterElementsPlugin(std::string const& reduction, int32_t dim) - : mReduction(gReduceToEnum.at(reduction)) +ScatterElementsPluginV3::ScatterElementsPluginV3(std::string const& reduction, int32_t dim) + : mReduction(kREDUCE_STR_TO_ENUM.at(reduction)) , mAxis(dim) { } -ScatterElementsPlugin::ScatterElementsPlugin(void const* serialData, size_t serialLength) -{ - deserialize_value(&serialData, &serialLength, &mReduction); - deserialize_value(&serialData, &serialLength, &mAxis); -} - -int32_t ScatterElementsPlugin::getNbOutputs() const noexcept +int32_t ScatterElementsPluginV3::getNbOutputs() const noexcept { return 1; } -int32_t ScatterElementsPlugin::initialize() noexcept +IPluginCapability* ScatterElementsPluginV3::getCapabilityInterface(PluginCapabilityType type) noexcept { - return 0; -} - -char const* ScatterElementsPlugin::getPluginType() const noexcept -{ - return kSCATTER_ELEMENTS_NAME; + try + { + if (type == PluginCapabilityType::kBUILD) + { + return static_cast(this); + } + if (type == PluginCapabilityType::kRUNTIME) + { + return static_cast(this); + } + PLUGIN_ASSERT(type == PluginCapabilityType::kCORE); + return static_cast(this); + } + catch (std::exception const& e) + { + caughtError(e); + } + return nullptr; } -char const* ScatterElementsPlugin::getPluginVersion() const noexcept +char const* ScatterElementsPluginV3::getPluginVersion() const noexcept { - return kSCATTER_ELEMENTS_VERSION; + return kSCATTER_PLUGIN_VERSION; } -DimsExprs ScatterElementsPlugin::getOutputDimensions( - int32_t index, DimsExprs const* inputs, int32_t nbInputs, IExprBuilder& exprBuilder) noexcept +int32_t ScatterElementsPluginV3::getOutputShapes(DimsExprs const* inputs, int32_t nbInputs, + DimsExprs const* shapeInputs, int32_t nbShapeInputs, DimsExprs* outputs, int32_t nbOutputs, + IExprBuilder& exprBuilder) noexcept { try { - PLUGIN_VALIDATE(nbInputs == 3); - PLUGIN_VALIDATE(inputs); - PLUGIN_VALIDATE(index <= kOUTPUT_TENSOR_IDX); - // both outputs are of the same size - DimsExprs out(inputs[kDATA_TENSOR_IDX]); - return out; + PLUGIN_ASSERT(nbInputs == 3); + PLUGIN_ASSERT(inputs != nullptr); + PLUGIN_ASSERT(nbOutputs == 1); + outputs[kOUTPUT_TENSOR_IDX] = inputs[kDATA_TENSOR_IDX]; + return pluginStatus_t::STATUS_SUCCESS; } catch (std::exception const& e) { caughtError(e); } - return DimsExprs(); + return pluginStatus_t::STATUS_FAILURE; } -int32_t ScatterElementsPlugin::enqueue(PluginTensorDesc const* inputDesc, PluginTensorDesc const* outputDesc, +int32_t ScatterElementsPluginV3::enqueue(PluginTensorDesc const* inputDesc, PluginTensorDesc const* outputDesc, void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept { try @@ -114,48 +127,67 @@ int32_t ScatterElementsPlugin::enqueue(PluginTensorDesc const* inputDesc, Plugin runScatterElementsKernel(outputs[kOUTPUT_TENSOR_IDX], inputs[kDATA_TENSOR_IDX], inputs[kUPDATES_TENSOR_IDX], inputs[kINDICES_TENSOR_IDX], outputDesc[kOUTPUT_TENSOR_IDX], inputDesc[kDATA_TENSOR_IDX], inputDesc[kUPDATES_TENSOR_IDX], inputDesc[kINDICES_TENSOR_IDX], mAxis, mReduction, stream); - return 0; + return pluginStatus_t::STATUS_SUCCESS; } catch (std::exception const& e) { caughtError(e); - return -1; } + return -1; } -size_t ScatterElementsPlugin::getSerializationSize() const noexcept +int32_t ScatterElementsPluginV3::onShapeChange( + PluginTensorDesc const* in, int32_t nbInputs, PluginTensorDesc const* out, int32_t nbOutputs) noexcept { - auto ret = serialized_size(mReduction) + serialized_size(mAxis); - return ret; + PLUGIN_ASSERT(in != nullptr); + PLUGIN_ASSERT(out != nullptr); + PLUGIN_ASSERT(nbOutputs == 1); + PLUGIN_ASSERT(nbInputs == 3); + auto rank = in[0].dims.nbDims; + // rank of input should be >=1 + PLUGIN_ASSERT(rank >= 1); + // rank of indices should be same as rank of data + PLUGIN_ASSERT(in[1].dims.nbDims == rank); + // rank and shape of updates should be same as indices + PLUGIN_ASSERT(in[2].dims.nbDims == rank); + PLUGIN_VALIDATE(std::equal(in[2].dims.d, in[2].dims.d + rank, in[1].dims.d)) + return pluginStatus_t::STATUS_SUCCESS; } -void ScatterElementsPlugin::serialize(void* buffer) const noexcept +PluginFieldCollection const* ScatterElementsPluginV3::getFieldsToSerialize() noexcept { - serialize_value(&buffer, mReduction); - serialize_value(&buffer, mAxis); + mDataToSerialize.clear(); + // "reduction" field is serialized as string + mDataToSerialize.emplace_back("reduction", kREDUCE_ENUM_TO_STR.at(mReduction).c_str(), PluginFieldType::kCHAR, + kREDUCE_ENUM_TO_STR.at(mReduction).size()); + mDataToSerialize.emplace_back("axis", &mAxis, PluginFieldType::kINT32, 1); + + mFCToSerialize.nbFields = mDataToSerialize.size(); + mFCToSerialize.fields = mDataToSerialize.data(); + return &mFCToSerialize; } -bool ScatterElementsPlugin::supportsFormatCombination( - int32_t pos, PluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept +bool ScatterElementsPluginV3::supportsFormatCombination( + int32_t pos, DynamicPluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept { try { PLUGIN_VALIDATE(inOut && pos < (nbInputs + nbOutputs)); - if (inOut[pos].format != PluginFormat::kLINEAR) + if (inOut[pos].desc.format != PluginFormat::kLINEAR) { return false; } - auto mytype = inOut[pos].type; - auto firsttype = inOut[kDATA_TENSOR_IDX].type; + auto currentType = inOut[pos].desc.type; + auto firstType = inOut[kDATA_TENSOR_IDX].desc.type; // Only INT64 is supported for indices - return pos == kINDICES_TENSOR_IDX ? (mytype == DataType::kINT64) - : (mytype == firsttype) - && (mytype == DataType::kFLOAT || mytype == DataType::kHALF - || (hasBfloat16AtomicAdd() && mytype == DataType::kBF16) || mytype == DataType::kINT32 - || mytype == DataType::kINT64); + return pos == kINDICES_TENSOR_IDX ? (currentType == DataType::kINT64) + : (currentType == firstType) + && (currentType == DataType::kFLOAT || currentType == DataType::kHALF + || (hasBfloat16AtomicAdd() && currentType == DataType::kBF16) || currentType == DataType::kINT32 + || currentType == DataType::kINT64); } catch (std::exception const& e) { @@ -164,70 +196,97 @@ bool ScatterElementsPlugin::supportsFormatCombination( } } -void ScatterElementsPlugin::terminate() noexcept {} - -void ScatterElementsPlugin::destroy() noexcept +ScatterElementsPluginV3* ScatterElementsPluginV3::clone() noexcept { - // This gets called when the network containing plugin is destroyed - delete this; + try + { + auto* plugin = new ScatterElementsPluginV3(mReduction, mAxis); + plugin->setPluginNamespace(mNamespace.c_str()); + return plugin; + } + catch (std::exception const& e) + { + caughtError(e); + } + return nullptr; } -IPluginV2DynamicExt* ScatterElementsPlugin::clone() const noexcept +IPluginV3* ScatterElementsPluginV3::attachToContext(IPluginResourceContext* context) noexcept { - auto* plugin = new ScatterElementsPlugin(mReduction, mAxis); - plugin->setPluginNamespace(mNamespace.c_str()); - return plugin; + ScatterElementsPluginV3* obj = clone(); + return obj; } -void ScatterElementsPlugin::configurePlugin( +int32_t ScatterElementsPluginV3::configurePlugin( DynamicPluginTensorDesc const* in, int32_t nbInputs, DynamicPluginTensorDesc const* out, int32_t nbOutputs) noexcept { try { PLUGIN_VALIDATE(nbInputs == 3); + return pluginStatus_t::STATUS_SUCCESS; } catch (std::exception const& e) { caughtError(e); } + return pluginStatus_t::STATUS_FAILURE; } -DataType ScatterElementsPlugin::getOutputDataType( - int32_t index, DataType const* inputTypes, int32_t nbInputs) const noexcept +int32_t ScatterElementsPluginV3::getOutputDataTypes( + DataType* outputTypes, int32_t nbOutputs, DataType const* inputTypes, int32_t nbInputs) const noexcept { try { - PLUGIN_VALIDATE(inputTypes && nbInputs == 3 && index == kOUTPUT_TENSOR_IDX); + PLUGIN_ASSERT(inputTypes != nullptr); + PLUGIN_ASSERT(nbInputs == 3); + PLUGIN_ASSERT(nbOutputs == 1); + outputTypes[kOUTPUT_TENSOR_IDX] = inputTypes[kDATA_TENSOR_IDX]; + return pluginStatus_t::STATUS_SUCCESS; } catch (std::exception const& e) { caughtError(e); } - return inputTypes[kDATA_TENSOR_IDX]; + return pluginStatus_t::STATUS_FAILURE; } -size_t ScatterElementsPlugin::getWorkspaceSize( - PluginTensorDesc const* inputs, int32_t nbInputs, PluginTensorDesc const* outputs, int32_t nbOutputs) const noexcept +size_t ScatterElementsPluginV3::getWorkspaceSize(DynamicPluginTensorDesc const* inputs, int32_t nbInputs, + DynamicPluginTensorDesc const* outputs, int32_t nbOutputs) const noexcept { return 0; } -void ScatterElementsPlugin::setPluginNamespace(char const* libNamespace) noexcept +void ScatterElementsPluginV3::setPluginNamespace(char const* libNamespace) noexcept { - mNamespace = libNamespace; + try + { + PLUGIN_ASSERT(libNamespace != nullptr); + mNamespace = libNamespace; + } + catch (std::exception const& e) + { + caughtError(e); + } +} + +char const* ScatterElementsPluginV3::getPluginName() const noexcept +{ + return kSCATTER_PLUGIN_NAME; } -char const* ScatterElementsPlugin::getPluginNamespace() const noexcept +char const* ScatterElementsPluginV3::getPluginNamespace() const noexcept { return mNamespace.c_str(); } // -// ScatterElementsPluginCreator +// ScatterElementsPluginV3Creator // -ScatterElementsPluginCreator::ScatterElementsPluginCreator() +ScatterElementsPluginV3Creator::ScatterElementsPluginV3Creator() { + static std::mutex sMutex; + std::lock_guard guard(sMutex); gPluginAttributes.clear(); gPluginAttributes.emplace_back(PluginField("reduction")); gPluginAttributes.emplace_back(PluginField("axis")); @@ -235,37 +294,38 @@ ScatterElementsPluginCreator::ScatterElementsPluginCreator() gFC.fields = gPluginAttributes.data(); } -char const* ScatterElementsPluginCreator::getPluginName() const noexcept +char const* ScatterElementsPluginV3Creator::getPluginName() const noexcept { - return kSCATTER_ELEMENTS_NAME; + return kSCATTER_PLUGIN_NAME; } -char const* ScatterElementsPluginCreator::getPluginVersion() const noexcept +char const* ScatterElementsPluginV3Creator::getPluginVersion() const noexcept { - return kSCATTER_ELEMENTS_VERSION; + return kSCATTER_PLUGIN_VERSION; } -PluginFieldCollection const* ScatterElementsPluginCreator::getFieldNames() noexcept +PluginFieldCollection const* ScatterElementsPluginV3Creator::getFieldNames() noexcept { return &gFC; } -char const* ScatterElementsPluginCreator::getPluginNamespace() const noexcept +char const* ScatterElementsPluginV3Creator::getPluginNamespace() const noexcept { return mNamespace.c_str(); } -void ScatterElementsPluginCreator::setPluginNamespace(char const* libNamespace) noexcept +void ScatterElementsPluginV3Creator::setPluginNamespace(char const* libNamespace) noexcept { + PLUGIN_VALIDATE(libNamespace != nullptr); mNamespace = libNamespace; } -IPluginV2DynamicExt* ScatterElementsPluginCreator::createPlugin( - char const* name, PluginFieldCollection const* fc) noexcept +IPluginV3* ScatterElementsPluginV3Creator::createPlugin( + char const* name, PluginFieldCollection const* fc, TensorRTPhase phase) noexcept { std::string reductionArg; int32_t axisArg = 0; - ScatterElementsPlugin* plugin = nullptr; + ScatterElementsPluginV3* plugin = nullptr; try { @@ -287,29 +347,22 @@ IPluginV2DynamicExt* ScatterElementsPluginCreator::createPlugin( else if (strcmp(fields[i].name, "reduction") == 0) { auto data = static_cast(fields[i].data); - reductionArg = std::string(data); + reductionArg = fields[i].length != -1 ? std::string(data, fields[i].length) : std::string(data); } } - PLUGIN_VALIDATE(gReduceToEnum.find(reductionArg) != gReduceToEnum.end(), + PLUGIN_VALIDATE(kREDUCE_STR_TO_ENUM.find(reductionArg) != kREDUCE_STR_TO_ENUM.end(), (reductionArg + ": invalid value for 'reduction' plugin argument").c_str()); - plugin = new ScatterElementsPlugin(reductionArg, axisArg); + plugin = new ScatterElementsPluginV3(reductionArg, axisArg); plugin->setPluginNamespace(mNamespace.c_str()); + return plugin; } catch (std::exception& e) { caughtError(e); } - return plugin; -} - -IPluginV2DynamicExt* ScatterElementsPluginCreator::deserializePlugin( - char const* name, void const* serialData, size_t serialLength) noexcept -{ - ScatterElementsPlugin* plugin = new ScatterElementsPlugin(serialData, serialLength); - plugin->setPluginNamespace(mNamespace.c_str()); - return plugin; + return nullptr; } } // namespace plugin diff --git a/plugin/scatterElementsPlugin/scatterElementsPlugin.h b/plugin/scatterElementsPlugin/scatterElementsPlugin.h index 01c2a73df..c0c784b76 100644 --- a/plugin/scatterElementsPlugin/scatterElementsPlugin.h +++ b/plugin/scatterElementsPlugin/scatterElementsPlugin.h @@ -17,117 +17,122 @@ #ifndef TRT_SCATTER_ELEMENTS_PLUGIN_H #define TRT_SCATTER_ELEMENTS_PLUGIN_H - +#include "NvInfer.h" +#include "NvInferPlugin.h" #include "common/plugin.h" -#include -#include -#include -#include +#include "scatterElementsCommon.h" namespace nvinfer1 { namespace plugin { -enum class ReductionType +class ScatterElementsPluginV3 : public IPluginV3, + public IPluginV3OneCore, + public IPluginV3OneBuild, + public IPluginV3OneRuntime { - kSUM, - kMUL, - kMEAN, - kMIN, - kMAX -}; +public: + // ctor and dtor + ScatterElementsPluginV3() = delete; -extern std::map const gReduceToEnum; + ScatterElementsPluginV3(ScatterElementsPluginV3 const&) = delete; -class ScatterElementsPlugin final : public nvinfer1::IPluginV2DynamicExt -{ -public: - ScatterElementsPlugin() = delete; - ScatterElementsPlugin(ScatterElementsPlugin const&) = delete; - ScatterElementsPlugin(std::string const&, int32_t); - ScatterElementsPlugin(ReductionType, int32_t); - ScatterElementsPlugin(void const* serialData, size_t serialLength); - ~ScatterElementsPlugin() override = default; + ScatterElementsPluginV3(std::string const&, int32_t); - int32_t getNbOutputs() const noexcept override; + ScatterElementsPluginV3(ReductionType, int32_t); - nvinfer1::DimsExprs getOutputDimensions(int32_t index, nvinfer1::DimsExprs const* inputs, int32_t nbInputDims, - nvinfer1::IExprBuilder& exprBuilder) noexcept override; + ~ScatterElementsPluginV3() override = default; - int32_t initialize() noexcept override; + // IPluginV3 Methods + IPluginCapability* getCapabilityInterface(PluginCapabilityType type) noexcept override; - void terminate() noexcept override; + ScatterElementsPluginV3* clone() noexcept; + // end IPluginV3 Methods - size_t getWorkspaceSize(nvinfer1::PluginTensorDesc const* inputs, int32_t nbInputs, - nvinfer1::PluginTensorDesc const* outputs, int32_t nbOutputs) const noexcept override; + // IPluginV3Core Methods + char const* getPluginVersion() const noexcept override; - int32_t enqueue(nvinfer1::PluginTensorDesc const* inputDesc, nvinfer1::PluginTensorDesc const* outputDesc, - void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept override; + char const* getPluginName() const noexcept override; + + char const* getPluginNamespace() const noexcept override; + + void setPluginNamespace(char const* pluginNamespace) noexcept; - size_t getSerializationSize() const noexcept override; + // end IPluginV3Core Methods - void serialize(void* buffer) const noexcept override; + // IPluginV3Build Methods + int32_t getNbOutputs() const noexcept override; bool supportsFormatCombination( - int32_t pos, nvinfer1::PluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept override; + int32_t pos, DynamicPluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept override; - char const* getPluginType() const noexcept override; + int32_t getOutputShapes(DimsExprs const* inputs, int32_t nbInputs, DimsExprs const* shapeInputs, + int32_t nbShapeInputs, DimsExprs* outputs, int32_t nbOutputs, IExprBuilder& exprBuilder) noexcept override; - char const* getPluginVersion() const noexcept override; + int32_t configurePlugin(DynamicPluginTensorDesc const* in, int32_t nbInputs, DynamicPluginTensorDesc const* out, + int32_t nbOutputs) noexcept override; - nvinfer1::IPluginV2DynamicExt* clone() const noexcept override; + size_t getWorkspaceSize(DynamicPluginTensorDesc const* inputs, int32_t nbInputs, + DynamicPluginTensorDesc const* outputs, int32_t nbOutputs) const noexcept override; - void destroy() noexcept override; + int32_t getOutputDataTypes( + DataType* outputTypes, int32_t nbOutputs, DataType const* inputTypes, int32_t nbInputs) const noexcept override; + // end IPluginV3Build Methods - nvinfer1::DataType getOutputDataType( - int32_t index, nvinfer1::DataType const* inputTypes, int32_t nbInputs) const noexcept override; + // IPluginV3Runtime Methods + int32_t enqueue(nvinfer1::PluginTensorDesc const* inputDesc, nvinfer1::PluginTensorDesc const* outputDesc, + void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept override; - void setPluginNamespace(char const* pluginNamespace) noexcept override; + int32_t onShapeChange( + PluginTensorDesc const* in, int32_t nbInputs, PluginTensorDesc const* out, int32_t nbOutputs) noexcept override; - char const* getPluginNamespace() const noexcept override; + IPluginV3* attachToContext(IPluginResourceContext* context) noexcept override; - void configurePlugin(nvinfer1::DynamicPluginTensorDesc const* in, int32_t nbInputs, - nvinfer1::DynamicPluginTensorDesc const* out, int32_t nbOutputs) noexcept override; + PluginFieldCollection const* getFieldsToSerialize() noexcept override; + // end IPluginV3Runtime Methods private: ReductionType mReduction; int32_t mAxis; + std::vector mDataToSerialize; + nvinfer1::PluginFieldCollection mFCToSerialize; std::string mNamespace; - + // input metadata static constexpr int32_t kINDICES_TENSOR_IDX = 1; static constexpr int32_t kUPDATES_TENSOR_IDX = 2; static constexpr int32_t kDATA_TENSOR_IDX = 0; - // outputs + // output metadata static constexpr int32_t kOUTPUT_TENSOR_IDX = 0; }; -class ScatterElementsPluginCreator : public nvinfer1::IPluginCreator +class ScatterElementsPluginV3Creator : public nvinfer1::IPluginCreatorV3One { public: - ScatterElementsPluginCreator(); + // ctor and dtor + ScatterElementsPluginV3Creator(); - ~ScatterElementsPluginCreator() override = default; + ~ScatterElementsPluginV3Creator() override = default; + // get plugin metadata char const* getPluginName() const noexcept override; char const* getPluginVersion() const noexcept override; nvinfer1::PluginFieldCollection const* getFieldNames() noexcept override; - nvinfer1::IPluginV2DynamicExt* createPlugin( - char const* name, nvinfer1::PluginFieldCollection const* fc) noexcept override; - - nvinfer1::IPluginV2DynamicExt* deserializePlugin( - char const* name, void const* serialData, size_t serialLength) noexcept override; + char const* getPluginNamespace() const noexcept override; - void setPluginNamespace(char const* pluginNamespace) noexcept override; + // setter + void setPluginNamespace(char const* libNamespace) noexcept; - char const* getPluginNamespace() const noexcept override; + // create plugin + IPluginV3* createPlugin( + char const* name, nvinfer1::PluginFieldCollection const* fc, TensorRTPhase phase) noexcept override; private: static nvinfer1::PluginFieldCollection gFC; - static std::vector gPluginAttributes; + static std::vector gPluginAttributes; std::string mNamespace; }; diff --git a/plugin/scatterElementsPlugin/scatterElementsPluginKernel.h b/plugin/scatterElementsPlugin/scatterElementsPluginKernel.h index 307ef355e..652ff2b58 100644 --- a/plugin/scatterElementsPlugin/scatterElementsPluginKernel.h +++ b/plugin/scatterElementsPlugin/scatterElementsPluginKernel.h @@ -25,6 +25,7 @@ #include "common/plugin.h" #include "scatterElementsPlugin.h" +#include "scatterElementsPluginLegacy.h" namespace nvinfer1 { diff --git a/plugin/scatterElementsPlugin/scatterElementsPluginLegacy.cpp b/plugin/scatterElementsPlugin/scatterElementsPluginLegacy.cpp new file mode 100644 index 000000000..0dfa582f3 --- /dev/null +++ b/plugin/scatterElementsPlugin/scatterElementsPluginLegacy.cpp @@ -0,0 +1,316 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "common/serialize.hpp" +#include "scatterElementsPluginKernel.h" +#include "scatterElementsPluginLegacy.h" + +namespace nvinfer1 +{ +namespace plugin +{ + +std::unordered_map const kREDUCE_STR_TO_ENUM{ + {"add", ReductionType::kSUM}, + {"mean", ReductionType::kMEAN}, + {"mul", ReductionType::kMUL}, + {"min", ReductionType::kMIN}, + {"max", ReductionType::kMAX}, +}; + +// Static class fields initialization +PluginFieldCollection ScatterElementsPluginV2Creator::gFC{}; +std::vector ScatterElementsPluginV2Creator::gPluginAttributes; + +namespace +{ +constexpr char const* kSCATTER_ELEMENTS_NAME{"ScatterElements"}; +constexpr char const* kSCATTER_ELEMENTS_VERSION{"1"}; +} // namespace + +ScatterElementsPluginV2::ScatterElementsPluginV2(ReductionType reduction, int32_t dim) + : mReduction(reduction) + , mAxis(dim) +{ +} + +ScatterElementsPluginV2::ScatterElementsPluginV2(std::string const& reduction, int32_t dim) + : mReduction(kREDUCE_STR_TO_ENUM.at(reduction)) + , mAxis(dim) +{ +} + +ScatterElementsPluginV2::ScatterElementsPluginV2(void const* serialData, size_t serialLength) +{ + deserialize_value(&serialData, &serialLength, &mReduction); + deserialize_value(&serialData, &serialLength, &mAxis); +} + +int32_t ScatterElementsPluginV2::getNbOutputs() const noexcept +{ + return 1; +} + +int32_t ScatterElementsPluginV2::initialize() noexcept +{ + return 0; +} + +char const* ScatterElementsPluginV2::getPluginType() const noexcept +{ + return kSCATTER_ELEMENTS_NAME; +} + +char const* ScatterElementsPluginV2::getPluginVersion() const noexcept +{ + return kSCATTER_ELEMENTS_VERSION; +} + +DimsExprs ScatterElementsPluginV2::getOutputDimensions( + int32_t index, DimsExprs const* inputs, int32_t nbInputs, IExprBuilder& exprBuilder) noexcept +{ + try + { + PLUGIN_VALIDATE(nbInputs == 3); + PLUGIN_VALIDATE(inputs); + PLUGIN_VALIDATE(index <= kOUTPUT_TENSOR_IDX); + // both outputs are of the same size + DimsExprs out(inputs[kDATA_TENSOR_IDX]); + return out; + } + catch (std::exception const& e) + { + caughtError(e); + } + return DimsExprs(); +} + +int32_t ScatterElementsPluginV2::enqueue(PluginTensorDesc const* inputDesc, PluginTensorDesc const* outputDesc, + void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept +{ + try + { + PLUGIN_VALIDATE(inputDesc[kINDICES_TENSOR_IDX].type == DataType::kINT64); + + runScatterElementsKernel(outputs[kOUTPUT_TENSOR_IDX], inputs[kDATA_TENSOR_IDX], inputs[kUPDATES_TENSOR_IDX], + inputs[kINDICES_TENSOR_IDX], outputDesc[kOUTPUT_TENSOR_IDX], inputDesc[kDATA_TENSOR_IDX], + inputDesc[kUPDATES_TENSOR_IDX], inputDesc[kINDICES_TENSOR_IDX], mAxis, mReduction, stream); + return 0; + } + catch (std::exception const& e) + { + caughtError(e); + return -1; + } +} + +size_t ScatterElementsPluginV2::getSerializationSize() const noexcept +{ + auto ret = serialized_size(mReduction) + serialized_size(mAxis); + return ret; +} + +void ScatterElementsPluginV2::serialize(void* buffer) const noexcept +{ + serialize_value(&buffer, mReduction); + serialize_value(&buffer, mAxis); +} + +bool ScatterElementsPluginV2::supportsFormatCombination( + int32_t pos, PluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept +{ + try + { + PLUGIN_VALIDATE(inOut && pos < (nbInputs + nbOutputs)); + + if (inOut[pos].format != PluginFormat::kLINEAR) + { + return false; + } + + auto mytype = inOut[pos].type; + auto firsttype = inOut[kDATA_TENSOR_IDX].type; + + // Only INT64 is supported for indices + return pos == kINDICES_TENSOR_IDX ? (mytype == DataType::kINT64) + : (mytype == firsttype) + && (mytype == DataType::kFLOAT || mytype == DataType::kHALF + || (hasBfloat16AtomicAdd() && mytype == DataType::kBF16) || mytype == DataType::kINT32 + || mytype == DataType::kINT64); + } + catch (std::exception const& e) + { + caughtError(e); + return false; + } +} + +void ScatterElementsPluginV2::terminate() noexcept {} + +void ScatterElementsPluginV2::destroy() noexcept +{ + // This gets called when the network containing plugin is destroyed + delete this; +} + +IPluginV2DynamicExt* ScatterElementsPluginV2::clone() const noexcept +{ + auto* plugin = new ScatterElementsPluginV2(mReduction, mAxis); + plugin->setPluginNamespace(mNamespace.c_str()); + return plugin; +} + +void ScatterElementsPluginV2::configurePlugin( + DynamicPluginTensorDesc const* in, int32_t nbInputs, DynamicPluginTensorDesc const* out, int32_t nbOutputs) noexcept +{ + try + { + PLUGIN_VALIDATE(nbInputs == 3); + } + catch (std::exception const& e) + { + caughtError(e); + } +} + +DataType ScatterElementsPluginV2::getOutputDataType( + int32_t index, DataType const* inputTypes, int32_t nbInputs) const noexcept +{ + try + { + PLUGIN_VALIDATE(inputTypes && nbInputs == 3 && index == kOUTPUT_TENSOR_IDX); + } + catch (std::exception const& e) + { + caughtError(e); + } + return inputTypes[kDATA_TENSOR_IDX]; +} + +size_t ScatterElementsPluginV2::getWorkspaceSize( + PluginTensorDesc const* inputs, int32_t nbInputs, PluginTensorDesc const* outputs, int32_t nbOutputs) const noexcept +{ + return 0; +} + +void ScatterElementsPluginV2::setPluginNamespace(char const* libNamespace) noexcept +{ + mNamespace = libNamespace; +} + +char const* ScatterElementsPluginV2::getPluginNamespace() const noexcept +{ + return mNamespace.c_str(); +} + +// +// ScatterElementsPluginV2Creator +// + +ScatterElementsPluginV2Creator::ScatterElementsPluginV2Creator() +{ + gPluginAttributes.clear(); + gPluginAttributes.emplace_back(PluginField("reduction")); + gPluginAttributes.emplace_back(PluginField("axis")); + gFC.nbFields = gPluginAttributes.size(); + gFC.fields = gPluginAttributes.data(); +} + +char const* ScatterElementsPluginV2Creator::getPluginName() const noexcept +{ + return kSCATTER_ELEMENTS_NAME; +} + +char const* ScatterElementsPluginV2Creator::getPluginVersion() const noexcept +{ + return kSCATTER_ELEMENTS_VERSION; +} + +PluginFieldCollection const* ScatterElementsPluginV2Creator::getFieldNames() noexcept +{ + return &gFC; +} + +char const* ScatterElementsPluginV2Creator::getPluginNamespace() const noexcept +{ + return mNamespace.c_str(); +} + +void ScatterElementsPluginV2Creator::setPluginNamespace(char const* libNamespace) noexcept +{ + mNamespace = libNamespace; +} + +IPluginV2DynamicExt* ScatterElementsPluginV2Creator::createPlugin( + char const* name, PluginFieldCollection const* fc) noexcept +{ + std::string reductionArg; + int32_t axisArg = 0; + ScatterElementsPluginV2* plugin = nullptr; + + try + { + PLUGIN_VALIDATE(fc != nullptr); + auto fields = fc->fields; + + std::set requiredFields{"reduction"}; + plugin::validateRequiredAttributesExist(requiredFields, fc); + + for (int32_t i = 0; i < fc->nbFields; ++i) + { + PLUGIN_VALIDATE(fields[i].name != nullptr); + PLUGIN_VALIDATE(fields[i].data != nullptr); + if (strcmp(fields[i].name, "axis") == 0) + { + auto data = static_cast(fields[i].data); + axisArg = *data; + } + else if (strcmp(fields[i].name, "reduction") == 0) + { + auto data = static_cast(fields[i].data); + reductionArg = std::string(data); + } + } + + PLUGIN_VALIDATE(kREDUCE_STR_TO_ENUM.find(reductionArg) != kREDUCE_STR_TO_ENUM.end(), + (reductionArg + ": invalid value for 'reduction' plugin argument").c_str()); + + plugin = new ScatterElementsPluginV2(reductionArg, axisArg); + plugin->setPluginNamespace(mNamespace.c_str()); + } + catch (std::exception& e) + { + caughtError(e); + } + return plugin; +} + +IPluginV2DynamicExt* ScatterElementsPluginV2Creator::deserializePlugin( + char const* name, void const* serialData, size_t serialLength) noexcept +{ + ScatterElementsPluginV2* plugin = new ScatterElementsPluginV2(serialData, serialLength); + plugin->setPluginNamespace(mNamespace.c_str()); + return plugin; +} + +} // namespace plugin +} // namespace nvinfer1 diff --git a/plugin/scatterElementsPlugin/scatterElementsPluginLegacy.h b/plugin/scatterElementsPlugin/scatterElementsPluginLegacy.h new file mode 100644 index 000000000..a2fc47782 --- /dev/null +++ b/plugin/scatterElementsPlugin/scatterElementsPluginLegacy.h @@ -0,0 +1,123 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TRT_SCATTER_ELEMENTS_PLUGIN_LEGACY_H +#define TRT_SCATTER_ELEMENTS_PLUGIN_LEGACY_H + +#include "common/plugin.h" +#include "scatterElementsCommon.h" + +namespace nvinfer1 +{ +namespace plugin +{ + +class ScatterElementsPluginV2 final : public nvinfer1::IPluginV2DynamicExt +{ +public: + ScatterElementsPluginV2() = delete; + ScatterElementsPluginV2(ScatterElementsPluginV2 const&) = delete; + ScatterElementsPluginV2(std::string const&, int32_t); + ScatterElementsPluginV2(ReductionType, int32_t); + ScatterElementsPluginV2(void const* serialData, size_t serialLength); + ~ScatterElementsPluginV2() override = default; + + int32_t getNbOutputs() const noexcept override; + + nvinfer1::DimsExprs getOutputDimensions(int32_t index, nvinfer1::DimsExprs const* inputs, int32_t nbInputDims, + nvinfer1::IExprBuilder& exprBuilder) noexcept override; + + int32_t initialize() noexcept override; + + void terminate() noexcept override; + + size_t getWorkspaceSize(nvinfer1::PluginTensorDesc const* inputs, int32_t nbInputs, + nvinfer1::PluginTensorDesc const* outputs, int32_t nbOutputs) const noexcept override; + + int32_t enqueue(nvinfer1::PluginTensorDesc const* inputDesc, nvinfer1::PluginTensorDesc const* outputDesc, + void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept override; + + size_t getSerializationSize() const noexcept override; + + void serialize(void* buffer) const noexcept override; + + bool supportsFormatCombination( + int32_t pos, nvinfer1::PluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept override; + + char const* getPluginType() const noexcept override; + + char const* getPluginVersion() const noexcept override; + + nvinfer1::IPluginV2DynamicExt* clone() const noexcept override; + + void destroy() noexcept override; + + nvinfer1::DataType getOutputDataType( + int32_t index, nvinfer1::DataType const* inputTypes, int32_t nbInputs) const noexcept override; + + void setPluginNamespace(char const* pluginNamespace) noexcept override; + + char const* getPluginNamespace() const noexcept override; + + void configurePlugin(nvinfer1::DynamicPluginTensorDesc const* in, int32_t nbInputs, + nvinfer1::DynamicPluginTensorDesc const* out, int32_t nbOutputs) noexcept override; + +private: + ReductionType mReduction; + int32_t mAxis; + std::string mNamespace; + + static constexpr int32_t kINDICES_TENSOR_IDX = 1; + static constexpr int32_t kUPDATES_TENSOR_IDX = 2; + static constexpr int32_t kDATA_TENSOR_IDX = 0; + // outputs + static constexpr int32_t kOUTPUT_TENSOR_IDX = 0; +}; + +class ScatterElementsPluginV2Creator : public nvinfer1::IPluginCreator +{ +public: + ScatterElementsPluginV2Creator(); + + ~ScatterElementsPluginV2Creator() override = default; + + char const* getPluginName() const noexcept override; + + char const* getPluginVersion() const noexcept override; + + nvinfer1::PluginFieldCollection const* getFieldNames() noexcept override; + + nvinfer1::IPluginV2DynamicExt* createPlugin( + char const* name, nvinfer1::PluginFieldCollection const* fc) noexcept override; + + nvinfer1::IPluginV2DynamicExt* deserializePlugin( + char const* name, void const* serialData, size_t serialLength) noexcept override; + + void setPluginNamespace(char const* pluginNamespace) noexcept override; + + char const* getPluginNamespace() const noexcept override; + +private: + static nvinfer1::PluginFieldCollection gFC; + static std::vector gPluginAttributes; + std::string mNamespace; +}; + +} // namespace plugin +} // namespace nvinfer1 + +#endif // TRT_SCATTER_ELEMENTS_PLUGIN_LEGACY_H diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 66034f8ba..49f5d8a11 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -113,6 +113,12 @@ message(STATUS "PY_CONFIG_INCLUDE: ${PY_CONFIG_INCLUDE}") include_directories(${TENSORRT_ROOT}/include ${PROJECT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR}/docstrings ${ONNX_INC_DIR} ${PYBIND11_DIR}) link_directories(${TENSORRT_BUILD}) +if (MSVC) + # Prevent pybind11 from sharing resources with other, potentially ABI incompatible modules + # https://github.com/pybind/pybind11/issues/2898 + add_definitions(-DPYBIND11_COMPILER_TYPE="_${PROJECT_NAME}_abi") +endif() + if (MSVC) message(STATUS "include_dirs: ${MSVC_COMPILER_DIR}/include ${MSVC_COMPILER_DIR}/../ucrt/include ${NV_WDKSDK_INC}/um ${NV_WDKSDK_INC}/shared") message(STATUS "link dirs: ${PY_LIB_DIR} ${NV_WDKSDK_LIB}/um/x64 ${MSVC_COMPILER_DIR}/lib/amd64 ${MSVC_COMPILER_DIR}/../ucrt/lib/x64") diff --git a/python/docstrings/infer/pyCoreDoc.h b/python/docstrings/infer/pyCoreDoc.h index b59803a92..39a52a9ba 100644 --- a/python/docstrings/infer/pyCoreDoc.h +++ b/python/docstrings/infer/pyCoreDoc.h @@ -713,8 +713,7 @@ constexpr char const* descr = R"trtdoc( :ivar streamable_weights_size: Returns the size of the streamable weights in the engine. This may not include all the weights. :ivar weight_streaming_budget_v2: Set and get the current weight streaming budget for inference. The budget may be set any non-negative value. A value of 0 streams the most weights. Values equal to streamable_weights_size (default) or larger will disable weight streaming. :ivar weight_streaming_scratch_memory_size: The amount of scratch memory required by a TensorRT ExecutionContext to perform inference. This value may change based on the current weight streaming budget. Please use the V2 memory APIs, engine.device_memory_size_v2 and ExecutionContext.set_device_memory() to provide memory which includes the current weight streaming scratch memory. Not specifying these APIs or using the V1 APIs will not include this memory, so TensorRT will resort to allocating itself. - )trtdoc" - ; + )trtdoc"; // Documentation bug with parameters on these three functions because they are overloaded. constexpr char const* serialize = R"trtdoc( @@ -1074,6 +1073,9 @@ constexpr char const* descr = R"trtdoc( constexpr char const* PROFILE_SHARING_0806 = R"trtdoc( [DEPRECATED] Allows optimization profiles to be shared across execution contexts. The default value for this flag is on in TensorRT 10.0. Turning if off is deprecated. )trtdoc"; +constexpr char const* ALIASED_PLUGIN_IO_10_03 = R"trtdoc( + Allows plugin I/O to be aliased when using IPluginV3OneBuildV2. +)trtdoc"; } // namespace PreviewFeatureDoc namespace HardwareCompatibilityLevelDoc diff --git a/python/docstrings/infer/pyGraphDoc.h b/python/docstrings/infer/pyGraphDoc.h index 09ef6cb18..cfd51ed84 100644 --- a/python/docstrings/infer/pyGraphDoc.h +++ b/python/docstrings/infer/pyGraphDoc.h @@ -198,8 +198,8 @@ constexpr const char* descr = R"trtdoc( :ivar dynamic_range: :class:`Tuple[float, float]` [DEPRECATED] Deprecated in TensorRT 10.1. Superseded by explicit quantization. A tuple containing the [minimum, maximum] of the dynamic range, or :class:`None` if the range was not set. :ivar is_shape: :class:`bool` Whether the tensor is a shape tensor. :ivar allowed_formats: :class:`int32` The allowed set of TensorFormat candidates. This should be an integer consisting of one or more :class:`TensorFormat` s, combined via bitwise OR after bit shifting. For example, ``1 << int(TensorFormat.CHW4) | 1 << int(TensorFormat.CHW32)``. -)trtdoc" - ; +)trtdoc"; + constexpr const char* set_dynamic_range = R"trtdoc( [DEPRECATED] Deprecated in TensorRT 10.1. Superseded by explicit quantization. Set dynamic range for the tensor. @@ -771,13 +771,13 @@ constexpr const char* descr = R"trtdoc( The slice layer has two variants, static and dynamic. Static slice specifies the start, size, and stride dimensions at layer creation time via :class:`Dims` and can use the get/set accessor functions of the :class:`ISliceLayer` . - Dynamic slice specifies one or more of start, size or stride as :class:`ITensor`s, by using :func:`ILayer.set_input` to add a second, third, or fourth input respectively. + Dynamic slice specifies one or more of start, size, stride, or axes as :class:`ITensor`s, by using :func:`ILayer.set_input` to add a second, third, fourth, or sixth input respectively. The corresponding :class:`Dims` are used if an input is missing or null. - An application can determine if the :class:`ISliceLayer` has a dynamic output shape based on whether the size input (third input) is present and non-null. + An application can determine if the :class:`ISliceLayer` has a dynamic output shape based on whether the size or axes input is present and non-null. The slice layer selects for each dimension a start location from within the input tensor, and copies elements to the output tensor using the specified stride across the input tensor. - Start, size, and stride tensors must be 1-D :class:`int32` shape tensors if not specified via :class:`Dims` . + Start, size, and stride tensors must be 1-D integer-typed shape tensors if not specified via :class:`Dims` . An example of using slice on a tensor: input = {{0, 2, 4}, {1, 3, 5}} @@ -786,17 +786,32 @@ constexpr const char* descr = R"trtdoc( stride = {1, 2} output = {{1, 5}} + If axes is provided then starts, ends, and strides must have the same length as axes and specifies a subset of dimensions to slice. If axes is not provided, starts, ends, and strides + must be of the same length as the rank of the input tensor. + + An example of using slice on a tensor with axes specified: + input = {{0, 2, 4}, {1, 3, 5}} + start = {1} + size = {2} + stride = {1} + axes = {1} + output = {{2, 4}, {3, 5}} + When the sampleMode is :const:`SampleMode.CLAMP` or :const:`SampleMode.REFLECT` , for each input dimension, if its size is 0 then the corresponding output dimension must be 0 too. + When the sampleMode is :const:`SampleMode.FILL`, the fifth input to the slice layer is used to determine the value to fill in out-of-bound indices. It is an error to specify the fifth input in any other sample mode. + A slice layer can produce a shape tensor if the following conditions are met: * ``start``, ``size``, and ``stride`` are build time constants, either as static :class:`Dims` or as constant input tensors. + * ``axes``, if provided, is a build time constant, either as static :class:`Dims` or as a constant input tensor. * The number of elements in the output tensor does not exceed 2 * :const:`Dims.MAX_DIMS` . The input tensor is a shape tensor if the output is a shape tensor. The following constraints must be satisfied to execute this layer on DLA: * ``start``, ``size``, and ``stride`` are build time constants, either as static :class:`Dims` or as constant input tensors. + * ``axes``, if provided, is a build time constant, either as static :class:`Dims` or as a constant input tensor. * sampleMode is :const:`SampleMode.STRICT_BOUNDS` . * Strides are 1 for all dimensions. * Slicing is not performed on the first dimension @@ -806,6 +821,7 @@ constexpr const char* descr = R"trtdoc( :ivar shape: :class:`Dims` The output dimensions. :ivar stride: :class:`Dims` The slicing stride. :ivar mode: :class:`SampleMode` Controls how :class:`ISliceLayer` handles out of bounds coordinates. + :ivar axes: :class:`Dims` The axes that starts, sizes, and strides correspond to. )trtdoc"; constexpr const char* set_input = R"trtdoc( @@ -823,6 +839,7 @@ constexpr const char* set_input = R"trtdoc( 2 The size tensor of the resulting slice, N-dimensional for Data, and 1-D for Shape. 3 The stride of the slicing operation, N-dimensional for Data, and 1-D for Shape. 4 Value for the :const:`SampleMode.FILL` slice mode. Disallowed for other modes. + 5 The axes tensor indicating the axes that starts, sizes, and strides correspond to. Must be a 1-D tensor. ===== ================================================================================== If this function is called with a value greater than 0, then :attr:`num_inputs` changes diff --git a/python/docstrings/infer/pyPluginDoc.h b/python/docstrings/infer/pyPluginDoc.h index f541a2810..c392d9425 100644 --- a/python/docstrings/infer/pyPluginDoc.h +++ b/python/docstrings/infer/pyPluginDoc.h @@ -420,6 +420,10 @@ constexpr const char* ipluginv3onebuild_descr = R"trtdoc( :ivar num_outputs: :class:`int` The number of outputs from the plugin. This is used by the implementations of :class:`INetworkDefinition` and :class:`Builder`. )trtdoc"; +constexpr const char* ipluginv3onebuildv2_descr = R"trtdoc( + A plugin capability interface that extends IPluginV3OneBuild by providing I/O aliasing functionality. +)trtdoc"; + constexpr const char* ipluginv3oneruntime_descr = R"trtdoc( A plugin capability interface that enables the runtime capability (PluginCapabilityType.RUNTIME). @@ -616,6 +620,35 @@ constexpr const char* get_valid_tactics = R"trtdoc( )trtdoc"; +constexpr const char* get_aliased_input = R"trtdoc( + Communicates to TensorRT that the output at the specified output index is aliased to the input at the returned index + + Enables read-modify-write behavior in plugins. TensorRT may insert copies to facilitate this capability. + + .. note:: + A given plugin input can only be aliased to a single plugin output. + + .. note:: + This API will only be called and have an effect when PreviewFeature.ALIASED_PLUGIN_IO_10_03 is turned on. + + .. warning:: + If an input is not shallow copyable, a copy inserted by TensorRT may not work as intended. Therefore, using this feature with tensors requiring deep copies is not supported. + + .. warning:: + If a given tensor is requested to be aliased by two different plugins, this may result in divergent copies of the tensor after writes from each plugin. e.g. In the below example, t1 and t2 could be divergent. + + +-----+ +--------+ + +->|Copy +--> t* ---->|Plugin0 +--> t1 + | +-----+ +--------+ + t + | +-----+ +--------+ + +->|Copy +--> t** --->|Plugin1 +--> t2 + +-----+ +--------+ + + :returns: An integer denoting the index of the input which is aliased to the output at output_index. Returning -1 indicates that the output is not aliased to any input. Otherwise, the valid range for return value is [0, nbInputs - 1]. + +)trtdoc"; + constexpr const char* attach_to_context = R"trtdoc( Clone the plugin, attach the cloned plugin object to a execution context and grant the cloned plugin access to some context resources. diff --git a/python/packaging/bindings_wheel/tensorrt/__init__.py b/python/packaging/bindings_wheel/tensorrt/__init__.py index 22022e9ea..ac1314d3a 100644 --- a/python/packaging/bindings_wheel/tensorrt/__init__.py +++ b/python/packaging/bindings_wheel/tensorrt/__init__.py @@ -195,7 +195,6 @@ def _itemsize(trt_type): fp8: 1, int4: 0.5, } - if trt_type in mapping: return mapping[trt_type] diff --git a/python/src/infer/pyCore.cpp b/python/src/infer/pyCore.cpp index e96597001..b92933f7e 100644 --- a/python/src/infer/pyCore.cpp +++ b/python/src/infer/pyCore.cpp @@ -1097,7 +1097,7 @@ void bindCore(py::module& m) .def("get_debug_state", &IExecutionContext::getDebugState, "name"_a, IExecutionContextDoc::get_debug_state) .def("set_all_tensors_debug_state", &IExecutionContext::setAllTensorsDebugState, "flag"_a, IExecutionContextDoc::set_all_tensors_debug_state) - ; + ; py::enum_(m, "ExecutionContextAllocationStrategy", py::arithmetic{}, ExecutionContextAllocationStrategyDoc::descr, py::module_local()) @@ -1293,7 +1293,7 @@ void bindCore(py::module& m) "weight_streaming_scratch_memory_size", &ICudaEngine::getWeightStreamingScratchMemorySize) // End weight streaming APIs .def("is_debug_tensor", &ICudaEngine::isDebugTensor, "name"_a, ICudaEngineDoc::is_debug_tensor) - .def("__del__", &utils::doNothingDel); + .def("__del__", &utils::doNothingDel); py::enum_(m, "AllocatorFlag", py::arithmetic{}, AllocatorFlagDoc::descr, py::module_local()) .value("RESIZABLE", AllocatorFlag::kRESIZABLE, AllocatorFlagDoc::RESIZABLE); @@ -1380,7 +1380,9 @@ void bindCore(py::module& m) QuantizationFlagDoc::CALIBRATE_BEFORE_FUSION); py::enum_(m, "PreviewFeature", PreviewFeatureDoc::descr, py::module_local()) - .value("PROFILE_SHARING_0806", PreviewFeature::kPROFILE_SHARING_0806, PreviewFeatureDoc::PROFILE_SHARING_0806); + .value("PROFILE_SHARING_0806", PreviewFeature::kPROFILE_SHARING_0806, PreviewFeatureDoc::PROFILE_SHARING_0806) + .value("ALIASED_PLUGIN_IO_10_03", PreviewFeature::kALIASED_PLUGIN_IO_10_03, + PreviewFeatureDoc::ALIASED_PLUGIN_IO_10_03); py::enum_( m, "HardwareCompatibilityLevel", HardwareCompatibilityLevelDoc::descr, py::module_local()) @@ -1493,7 +1495,7 @@ void bindCore(py::module& m) .def_property("max_aux_streams", &IBuilderConfig::getMaxAuxStreams, &IBuilderConfig::setMaxAuxStreams) .def_property("progress_monitor", &IBuilderConfig::getProgressMonitor, py::cpp_function(&IBuilderConfig::setProgressMonitor, py::keep_alive<1, 2>{})) - .def("__del__", &utils::doNothingDel); + .def("__del__", &utils::doNothingDel); py::enum_(m, "NetworkDefinitionCreationFlag", py::arithmetic{}, NetworkDefinitionCreationFlagDoc::descr, py::module_local()) @@ -1539,7 +1541,7 @@ void bindCore(py::module& m) .def("deserialize_cuda_engine", py::overload_cast(&IRuntime::deserializeCudaEngine), "stream_reader"_a, RuntimeDoc::deserialize_cuda_engine_reader, py::call_guard{}, py::keep_alive<0, 1>{}) - .def_property("DLA_core", &IRuntime::getDLACore, &IRuntime::setDLACore) + .def_property("DLA_core", &IRuntime::getDLACore, &IRuntime::setDLACore) .def_property_readonly("num_DLA_cores", &IRuntime::getNbDLACores) .def_property("gpu_allocator", nullptr, py::cpp_function(&IRuntime::setGpuAllocator, py::keep_alive<1, 2>{})) .def_property("error_recorder", &IRuntime::getErrorRecorder, diff --git a/python/src/infer/pyGraph.cpp b/python/src/infer/pyGraph.cpp index f6ebbfe0e..e2d8564a9 100644 --- a/python/src/infer/pyGraph.cpp +++ b/python/src/infer/pyGraph.cpp @@ -23,6 +23,7 @@ #if ENABLE_INETWORK_SERIALIZE #include "NvInferSerialize.h" #endif + #include "infer/pyGraphDoc.h" // clang-format off @@ -243,7 +244,6 @@ namespace tensorrt else return py::cast(self.getBeta()); }; - } /* lambdas */ void bindGraph(py::module& m) @@ -297,6 +297,7 @@ namespace tensorrt .value("REVERSE_SEQUENCE", LayerType::kREVERSE_SEQUENCE, LayerTypeDoc::REVERSE_SEQUENCE) .value("NORMALIZATION", LayerType::kNORMALIZATION, LayerTypeDoc::NORMALIZATION) .value("PLUGIN_V3", LayerType::kPLUGIN_V3, LayerTypeDoc::PLUGIN_V3) + ; // LayerType py::enum_(m, "TensorFormat", TensorFormatDoc::descr, py::arithmetic{}, py::module_local()) @@ -450,7 +451,6 @@ namespace tensorrt .def_property("axis", &IDequantizeLayer::getAxis, &IDequantizeLayer::setAxis) .def_property("to_type", &IDequantizeLayer::getToType, &IDequantizeLayer::setToType) ; - py::class_>(m, "ISoftMaxLayer", ISoftMaxLayerDoc::descr, py::module_local()) .def_property("axes", &ISoftMaxLayer::getAxes, &ISoftMaxLayer::setAxes) ; @@ -605,6 +605,7 @@ namespace tensorrt .def_property("stride", &ISliceLayer::getStride, &ISliceLayer::setStride) .def_property("mode", &ISliceLayer::getMode, &ISliceLayer::setMode) .def("set_input", &ISliceLayer::setInput, "index"_a, "tensor"_a, ISliceLayerDoc::set_input) + .def_property("axes", &ISliceLayer::getAxes, &ISliceLayer::setAxes) ; py::enum_(m, "InterpolationMode", InterpolationModeDoc::descr, py::module_local()) diff --git a/python/src/infer/pyPlugin.cpp b/python/src/infer/pyPlugin.cpp index 671a14c39..e7c8caa1b 100644 --- a/python/src/infer/pyPlugin.cpp +++ b/python/src/infer/pyPlugin.cpp @@ -38,7 +38,7 @@ } #define PLUGIN_API_CATCH_CAST(func, returnType) \ - catch (const py::cast_error& e) \ + catch (py::cast_error const& e) \ { \ std::cerr << "[ERROR] Return value of " << (func) << "() could not be interpreted as " << (returnType) \ << std::endl; \ @@ -786,7 +786,18 @@ class PyIPluginV3Impl : public IPluginV3 } if (type == PluginCapabilityType::kBUILD) { - return pyResult.cast(); + try + { + return pyResult.cast(); + } + catch (py::cast_error const& e) + { + try + { + return pyResult.cast(); + } + PLUGIN_API_CATCH_CAST("get_capability_interface", " a valid build capability interface") + } } if (type == PluginCapabilityType::kRUNTIME) { @@ -937,13 +948,19 @@ class PyIPluginResourceImpl : public IPluginResource } }; -class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild +template +class PyIPluginV3OneBuildBaseImpl : public T { -public: - using IPluginV3OneBuild::IPluginV3OneBuild; - PyIPluginV3OneBuildImpl() = default; - PyIPluginV3OneBuildImpl(const IPluginV3OneBuild& a){}; +private: + T* mBuild{nullptr}; +protected: + PyIPluginV3OneBuildBaseImpl(T* build) + : mBuild{build} + { + } + +public: APILanguage getAPILanguage() const noexcept final { return APILanguage::kPYTHON; @@ -972,8 +989,7 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild try { - py::function pyGetValidTactics - = py::get_override(static_cast(this), "get_valid_tactics"); + py::function pyGetValidTactics = py::get_override(static_cast(mBuild), "get_valid_tactics"); mIsTacticsInitialized = true; @@ -1047,7 +1063,7 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild py::gil_scoped_acquire gil{}; py::function pySupportsFormatCombination - = utils::getOverride(static_cast(this), "supports_format_combination"); + = utils::getOverride(static_cast(mBuild), "supports_format_combination"); if (!pySupportsFormatCombination) { utils::throwPyError(PyExc_RuntimeError, "no implementation provided for supports_format_combination()"); @@ -1081,7 +1097,7 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild py::gil_scoped_acquire gil{}; py::function pyGetOutputDataTypes - = utils::getOverride(static_cast(this), "get_output_data_types"); + = utils::getOverride(static_cast(mBuild), "get_output_data_types"); if (!pyGetOutputDataTypes) { utils::throwPyError(PyExc_RuntimeError, "no implementation provided for get_output_data_types()"); @@ -1124,8 +1140,7 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild { py::gil_scoped_acquire gil{}; - py::function pyGetOutputShapes - = utils::getOverride(static_cast(this), "get_output_shapes"); + py::function pyGetOutputShapes = utils::getOverride(static_cast(mBuild), "get_output_shapes"); if (!pyGetOutputShapes) { utils::throwPyError(PyExc_RuntimeError, "no implementation provided for get_output_shapes()"); @@ -1174,8 +1189,7 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild { py::gil_scoped_acquire gil{}; - py::function pyConfigurePlugin - = utils::getOverride(static_cast(this), "configure_plugin"); + py::function pyConfigurePlugin = utils::getOverride(static_cast(mBuild), "configure_plugin"); if (!pyConfigurePlugin) { @@ -1215,8 +1229,7 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild { py::gil_scoped_acquire gil{}; - py::function pyGetWorkspaceSize - = py::get_override(static_cast(this), "get_workspace_size"); + py::function pyGetWorkspaceSize = py::get_override(static_cast(mBuild), "get_workspace_size"); if (!pyGetWorkspaceSize) { @@ -1333,6 +1346,57 @@ class PyIPluginV3OneBuildImpl : public IPluginV3OneBuild bool mIsTacticsInitialized{false}; }; +class PyIPluginV3OneBuildImpl : public PyIPluginV3OneBuildBaseImpl +{ +public: + PyIPluginV3OneBuildImpl() + : PyIPluginV3OneBuildBaseImpl(this) + { + } + PyIPluginV3OneBuildImpl(IPluginV3OneBuild const& a) + : PyIPluginV3OneBuildBaseImpl(this){}; +}; + +class PyIPluginV3OneBuildV2Impl : public PyIPluginV3OneBuildBaseImpl +{ +public: + PyIPluginV3OneBuildV2Impl() + : PyIPluginV3OneBuildBaseImpl(this) + { + } + PyIPluginV3OneBuildV2Impl(IPluginV3OneBuildV2 const& a) + : PyIPluginV3OneBuildBaseImpl(this){}; + + int32_t getAliasedInput(int32_t outputIndex) noexcept override + { + try + { + py::gil_scoped_acquire gil{}; + + py::function pyGetAliasedInput + = py::get_override(static_cast(this), "get_aliased_input"); + + if (!pyGetAliasedInput) + { + // if no implementation is provided for get_aliased_input(), default to no aliasing + return -1; + } + + py::object pyResult = pyGetAliasedInput(outputIndex); + + try + { + auto result = pyResult.cast(); + return result; + } + PLUGIN_API_CATCH_CAST("get_aliased_input", "int32_t") + return 0U; + } + PLUGIN_API_CATCH("get_aliased_input") + return -1; + } +}; + class PyIPluginV3OneRuntimeImpl : public IPluginV3OneRuntime { public: @@ -2265,6 +2329,11 @@ IPluginResource* clonePluginResource(IPluginResource& self) return nullptr; } +int32_t getAliasedInput(int32_t outputIndex) +{ + return -1; +} + } // namespace pluginDoc void bindPlugin(py::module& m) @@ -2503,7 +2572,7 @@ void bindPlugin(py::module& m) .def_property("timing_cache_id", &IPluginV3OneBuild::getTimingCacheID, py::cpp_function(lambdas::IPluginV3_get_timing_cache_id, py::keep_alive<1, 2>{})) // The following defs are only for documenting the API for Python-based plugins - .def("get_output_datatypes", &pluginDoc::getOutputDataTypes, "input_types"_a, + .def("get_output_data_types", &pluginDoc::getOutputDataTypes, "input_types"_a, IPluginV3Doc::get_output_data_types) .def("get_output_shapes", &pluginDoc::getOutputShapes, "inputs"_a, "shape_inputs"_a, "expr_builder"_a, IPluginV3Doc::get_output_shapes) @@ -2513,6 +2582,14 @@ void bindPlugin(py::module& m) "num_inputs"_a, IPluginV3Doc::supports_format_combination) .def("get_valid_tactics", &pluginDoc::getValidTactics, IPluginV3Doc::get_valid_tactics); + py::class_>( + m, "IPluginV3OneBuildV2", IPluginV3Doc::ipluginv3onebuildv2_descr, py::module_local()) + .def(py::init<>()) + .def(py::init()) + // The following defs are only for documenting the API for Python-based plugins + .def("get_aliased_input", &pluginDoc::getAliasedInput, IPluginV3Doc::get_valid_tactics); + py::class_>( m, "IPluginV3OneRuntime", IPluginV3Doc::ipluginv3oneruntime_descr, py::module_local()) diff --git a/quickstart/Makefile.config b/quickstart/Makefile.config index 0d290ea59..330658997 100644 --- a/quickstart/Makefile.config +++ b/quickstart/Makefile.config @@ -106,7 +106,6 @@ CUDART_LIB = -lcudart CUDNN_LIB = -lcudnn CUBLAS_LIB = -lcublas NVINFER_LIB = -lnvinfer -NVPARSERS_LIB = -lnvparsers NVINFER_PLUGIN_LIB = -lnvinfer_plugin NVONNXPARSERS_LIB = -lnvonnxparser NVRTC_LIB = -lnvrtc @@ -168,8 +167,8 @@ ifeq ($(USE_CUDART_STATIC), 1) COMMON_LIBS_FOR_EXECUTABLE += $(CUDART_LIB) endif -LIBS = $(NVINFER_LIB) $(NVPARSERS_LIB) $(NVINFER_PLUGIN_LIB) $(NVONNXPARSERS_LIB) $(COMMON_LIBS_FOR_EXECUTABLE) $(PROTO_LIB) $(EXTRA_LIBS) -DLIBS = $(NVINFER_LIB) $(NVPARSERS_LIB) $(NVINFER_PLUGIN_LIB) $(NVONNXPARSERS_LIB) $(COMMON_LIBS_FOR_EXECUTABLE) $(PROTO_LIB) $(EXTRA_LIBS) +LIBS = $(NVINFER_LIB) $(NVINFER_PLUGIN_LIB) $(NVONNXPARSERS_LIB) $(COMMON_LIBS_FOR_EXECUTABLE) $(PROTO_LIB) $(EXTRA_LIBS) +DLIBS = $(NVINFER_LIB) $(NVINFER_PLUGIN_LIB) $(NVONNXPARSERS_LIB) $(COMMON_LIBS_FOR_EXECUTABLE) $(PROTO_LIB) $(EXTRA_LIBS) OBJS = $(patsubst %.cpp, $(OBJDIR)/%.o, $(wildcard *.cpp $(addsuffix /*.cpp, $(EXTRA_DIRECTORIES)))) DOBJS = $(patsubst %.cpp, $(DOBJDIR)/%.o, $(wildcard *.cpp $(addsuffix /*.cpp, $(EXTRA_DIRECTORIES)))) diff --git a/quickstart/SemanticSegmentation/tutorial-runtime.cpp b/quickstart/SemanticSegmentation/tutorial-runtime.cpp index c1f09197c..7d85663a9 100644 --- a/quickstart/SemanticSegmentation/tutorial-runtime.cpp +++ b/quickstart/SemanticSegmentation/tutorial-runtime.cpp @@ -54,7 +54,8 @@ class SampleSegmentation nvinfer1::Dims mInputDims; //!< The dimensions of the input to the network. nvinfer1::Dims mOutputDims; //!< The dimensions of the output to the network. - util::UniquePtr mEngine; //!< The TensorRT engine used to run the network + std::unique_ptr mRuntime; //!< The TensorRT runtime used to run the network + std::unique_ptr mEngine; //!< The TensorRT engine used to run the network }; SampleSegmentation::SampleSegmentation(const std::string& engineFilename) @@ -75,8 +76,8 @@ SampleSegmentation::SampleSegmentation(const std::string& engineFilename) std::vector engineData(fsize); engineFile.read(engineData.data(), fsize); - util::UniquePtr runtime{nvinfer1::createInferRuntime(sample::gLogger.getTRTLogger())}; - mEngine.reset(runtime->deserializeCudaEngine(engineData.data(), fsize, nullptr)); + mRuntime.reset(nvinfer1::createInferRuntime(sample::gLogger.getTRTLogger())); + mEngine.reset(mRuntime->deserializeCudaEngine(engineData.data(), fsize)); assert(mEngine.get() != nullptr); } @@ -87,30 +88,22 @@ SampleSegmentation::SampleSegmentation(const std::string& engineFilename) //! bool SampleSegmentation::infer(const std::string& input_filename, int32_t width, int32_t height, const std::string& output_filename) { - auto context = util::UniquePtr(mEngine->createExecutionContext()); + auto context = std::unique_ptr(mEngine->createExecutionContext()); if (!context) { return false; } - auto input_idx = mEngine->getBindingIndex("input"); - if (input_idx == -1) - { - return false; - } - assert(mEngine->getBindingDataType(input_idx) == nvinfer1::DataType::kFLOAT); - auto input_dims = nvinfer1::Dims4{1, 3 /* channels */, height, width}; - context->setBindingDimensions(input_idx, input_dims); + char const* input_name = "input"; + assert(mEngine->getTensorDataType(input_name) == nvinfer1::DataType::kFLOAT); + auto input_dims = nvinfer1::Dims4{1, /* channels */ 3, height, width}; + context->setInputShape(input_name, input_dims); auto input_size = util::getMemorySize(input_dims, sizeof(float)); - auto output_idx = mEngine->getBindingIndex("output"); - if (output_idx == -1) - { - return false; - } - assert(mEngine->getBindingDataType(output_idx) == nvinfer1::DataType::kINT32); - auto output_dims = context->getBindingDimensions(output_idx); - auto output_size = util::getMemorySize(output_dims, sizeof(int32_t)); + char const* output_name = "output"; + assert(mEngine->getTensorDataType(output_name) == nvinfer1::DataType::kINT64); + auto output_dims = context->getTensorShape(output_name); + auto output_size = util::getMemorySize(output_dims, sizeof(int64_t)); // Allocate CUDA memory for input and output bindings void* input_mem{nullptr}; @@ -145,10 +138,11 @@ bool SampleSegmentation::infer(const std::string& input_filename, int32_t width, gLogError << "ERROR: CUDA memory copy of input failed, size = " << input_size << " bytes" << std::endl; return false; } + context->setTensorAddress(input_name, input_mem); + context->setTensorAddress(output_name, output_mem); // Run TensorRT inference - void* bindings[] = {input_mem, output_mem}; - bool status = context->enqueueV2(bindings, stream, nullptr); + bool status = context->enqueueV3(stream); if (!status) { gLogError << "ERROR: TensorRT inference failed" << std::endl; @@ -156,7 +150,7 @@ bool SampleSegmentation::infer(const std::string& input_filename, int32_t width, } // Copy predictions from output binding memory - auto output_buffer = std::unique_ptr{new int[output_size]}; + auto output_buffer = std::unique_ptr{new int64_t[output_size]}; if (cudaMemcpyAsync(output_buffer.get(), output_mem, output_size, cudaMemcpyDeviceToHost, stream) != cudaSuccess) { gLogError << "ERROR: CUDA memory copy of output failed, size = " << output_size << " bytes" << std::endl; @@ -168,7 +162,12 @@ bool SampleSegmentation::infer(const std::string& input_filename, int32_t width, const int num_classes{21}; const std::vector palette{(0x1 << 25) - 1, (0x1 << 15) - 1, (0x1 << 21) - 1}; auto output_image{util::ArgmaxImageWriter(output_filename, output_dims, palette, num_classes)}; - output_image.process(output_buffer.get()); + int64_t* output_ptr = output_buffer.get(); + std::vector output_buffer_casted(output_size); + for (size_t i = 0; i < output_size; ++i) { + output_buffer_casted[i] = static_cast(output_ptr[i]); + } + output_image.process(output_buffer_casted.data()); output_image.write(); // Free CUDA resources diff --git a/quickstart/SemanticSegmentation/tutorial-runtime.ipynb b/quickstart/SemanticSegmentation/tutorial-runtime.ipynb index 3258bd28f..d0058498a 100644 --- a/quickstart/SemanticSegmentation/tutorial-runtime.ipynb +++ b/quickstart/SemanticSegmentation/tutorial-runtime.ipynb @@ -7,7 +7,7 @@ "outputs": [], "source": [ "#\n", - "# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.\n", + "# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.\n", "#\n", "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", @@ -30,6 +30,11 @@ "### Check the TensorRT version" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, { "cell_type": "code", "execution_count": 2, @@ -39,7 +44,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "TensorRT version: 7.2.2.1\r\n" + "TensorRT version: 10.2.0.post1\n" ] } ], @@ -51,13 +56,57 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Import required modules" + "### Prepare the input image and ONNX model file" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/usr/lib/python3/dist-packages/requests/__init__.py:87: RequestsDependencyWarning: urllib3 (2.0.7) or chardet (4.0.0) doesn't match a supported version!\n", + " warnings.warn(\"urllib3 ({}) or chardet ({}) doesn't match a supported \"\n", + "Exporting ppm image input.ppm\n", + "Using cache found in /home/simengl/.cache/torch/hub/pytorch_vision_v0.6.0\n", + "Exporting ONNX model fcn-resnet101.onnx\n" + ] + } + ], + "source": [ + "!python3 export.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Build TensorRT engine from the ONNX model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "!trtexec --onnx=fcn-resnet101.onnx --saveEngine=fcn-resnet101.engine --optShapes=input:1x3x1026x1282" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import required modules" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -77,6 +126,11 @@ "output_file = \"output.ppm\"" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -86,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -127,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -162,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -174,32 +228,37 @@ " image_height = img.height\n", "\n", " with engine.create_execution_context() as context:\n", - " # Set input shape based on image dimensions for inference\n", - " context.set_binding_shape(engine.get_binding_index(\"input\"), (1, 3, image_height, image_width))\n", " # Allocate host and device buffers\n", - " bindings = []\n", - " for binding in engine:\n", - " binding_idx = engine.get_binding_index(binding)\n", - " size = trt.volume(context.get_binding_shape(binding_idx))\n", - " dtype = trt.nptype(engine.get_binding_dtype(binding))\n", - " if engine.binding_is_input(binding):\n", + " tensor_names = [engine.get_tensor_name(i) for i in range(engine.num_io_tensors)]\n", + " for tensor in tensor_names:\n", + " size = trt.volume(context.get_tensor_shape(tensor))\n", + " dtype = trt.nptype(engine.get_tensor_dtype(tensor))\n", + " \n", + " if engine.get_tensor_mode(tensor) == trt.TensorIOMode.INPUT:\n", + " context.set_input_shape(tensor, (1, 3, image_height, image_width))\n", " input_buffer = np.ascontiguousarray(input_image)\n", " input_memory = cuda.mem_alloc(input_image.nbytes)\n", - " bindings.append(int(input_memory))\n", + " context.set_tensor_address(tensor, int(input_memory))\n", " else:\n", " output_buffer = cuda.pagelocked_empty(size, dtype)\n", " output_memory = cuda.mem_alloc(output_buffer.nbytes)\n", - " bindings.append(int(output_memory))\n", + " context.set_tensor_address(tensor, int(output_memory))\n", "\n", " stream = cuda.Stream()\n", + " \n", " # Transfer input data to the GPU.\n", " cuda.memcpy_htod_async(input_memory, input_buffer, stream)\n", + " \n", " # Run inference\n", - " context.execute_async_v2(bindings=bindings, stream_handle=stream.handle)\n", + " context.execute_async_v3(stream_handle=stream.handle)\n", + " \n", " # Transfer prediction output from the GPU.\n", " cuda.memcpy_dtoh_async(output_buffer, output_memory, stream)\n", + " \n", " # Synchronize the stream\n", " stream.synchronize()\n", + " output_d64 = np.array(output_buffer, dtype=np.int64)\n", + " np.savetxt('test.out', output_d64.astype(int), fmt='%i', delimiter=' ', newline=' ')\n", "\n", " with postprocess(np.reshape(output_buffer, (image_height, image_width))) as img:\n", " print(\"Writing output image to file {}\".format(output_file))\n", @@ -215,29 +274,27 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -254,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -262,7 +319,14 @@ "output_type": "stream", "text": [ "Running TensorRT inference for FCN-ResNet101\n", - "Reading engine from file fcn-resnet101.engine\n", + "Reading engine from file fcn-resnet101.engine\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[07/31/2024-12:07:11] [TRT] [W] Using an engine plan file across different models of devices is not recommended and is likely to affect performance or even cause errors.\n", "Reading input image from file input.ppm\n", "Writing output image to file output.ppm\n" ] @@ -283,29 +347,27 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -316,7 +378,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -330,7 +392,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/quickstart/common/logging.h b/quickstart/common/logging.h index d891e1686..9b722c5e9 100644 --- a/quickstart/common/logging.h +++ b/quickstart/common/logging.h @@ -242,7 +242,7 @@ class Logger : public nvinfer1::ILogger //! Note samples should not be calling this function directly; it will eventually go away once we eliminate the //! inheritance from nvinfer1::ILogger //! - void log(Severity severity, const char* msg) override + void log(Severity severity, const char* msg) noexcept override { LogStreamConsumer(mReportableSeverity, severity) << "[TRT] " << std::string(msg) << std::endl; } diff --git a/quickstart/common/util.h b/quickstart/common/util.h index 554579694..c798a4524 100644 --- a/quickstart/common/util.h +++ b/quickstart/common/util.h @@ -26,21 +26,6 @@ namespace util { -struct InferDeleter -{ - template - void operator()(T* obj) const - { - if (obj) - { - obj->destroy(); - } - } -}; - -template -using UniquePtr = std::unique_ptr; - size_t getMemorySize(const nvinfer1::Dims& dims, const int32_t elem_size); struct PPM diff --git a/requirements.txt b/requirements.txt index bb70e1071..6f4c68798 100644 --- a/requirements.txt +++ b/requirements.txt @@ -11,7 +11,7 @@ torchvision==0.11.3; python_version<"3.10" torchvision==0.12.0; python_version=="3.10" Pillow numpy -pycuda +pycuda==2024.1 pytest --extra-index-url https://pypi.ngc.nvidia.com onnx-graphsurgeon diff --git a/samples/common/sampleEngines.cpp b/samples/common/sampleEngines.cpp index 2fc29eaaa..f56e335fd 100644 --- a/samples/common/sampleEngines.cpp +++ b/samples/common/sampleEngines.cpp @@ -675,8 +675,7 @@ void setPreviewFeatures(IBuilderConfig& config, BuildOptions const& build) config.setPreviewFeature(feat, build.previewFeatures.at(featVal)); } }; - // unused - static_cast(setFlag); + setFlag(PreviewFeature::kALIASED_PLUGIN_IO_10_03); } } // namespace @@ -1218,7 +1217,7 @@ bool networkToSerializedEngine( { if (!checkSafeEngine(serializedEngine->data(), serializedEngine->size())) { - sample::gLogError << "Consistency validation is not successful." << std::endl; + sample::gLogError << "Consistency validation is not supported." << std::endl; return false; } } @@ -1365,7 +1364,7 @@ bool loadEngineToBuildEnv(std::string const& filepath, bool enableConsistency, B { if (!checkSafeEngine(engineBlob.data(), fsize)) { - sample::gLogError << "Consistency validation is not successful." << std::endl; + sample::gLogError << "Consistency validation is not enabled." << std::endl; return false; } } @@ -1801,25 +1800,6 @@ nvinfer1::consistency::IConsistencyChecker* createConsistencyChecker( bool checkSafeEngine(void const* serializedEngine, int32_t const engineSize) { - if (!hasConsistencyChecker()) - { - sample::gLogError << "Cannot perform consistency check because the checker is not loaded.." << std::endl; - return false; - } - auto checker = std::unique_ptr( - createConsistencyChecker(sample::gLogger.getTRTLogger(), serializedEngine, engineSize)); - if (checker.get() == nullptr) - { - sample::gLogError << "Failed to create consistency checker." << std::endl; - return false; - } - sample::gLogInfo << "Start consistency checking." << std::endl; - if (!checker->validate()) - { - sample::gLogError << "Consistency validation failed." << std::endl; - return false; - } - sample::gLogInfo << "Consistency validation passed." << std::endl; - return true; + return hasConsistencyChecker(); } } // namespace sample diff --git a/samples/common/sampleOptions.cpp b/samples/common/sampleOptions.cpp index 802c02ad4..c4235a498 100644 --- a/samples/common/sampleOptions.cpp +++ b/samples/common/sampleOptions.cpp @@ -905,6 +905,7 @@ std::string previewFeatureToString(PreviewFeature feature) gLogWarning << "profileSharing0806 is on by default in TensorRT 10.0. This flag is deprecated and has no effect." << std::endl; break; } + case PreviewFeature::kALIASED_PLUGIN_IO_10_03: return "kALIASED_PLUGIN_IO_10_03"; } return "Invalid Preview Feature"; // clang-format on @@ -925,8 +926,8 @@ std::ostream& printPreviewFlags(std::ostream& os, BuildOptions const& options) os << previewFeatureToString(feat) << (options.previewFeatures.at(featVal) ? " [ON], " : " [OFF], "); } }; - // unused - static_cast(addFlag); + + addFlag(PreviewFeature::kALIASED_PLUGIN_IO_10_03); return os; } @@ -1510,6 +1511,10 @@ void BuildOptions::parse(Arguments& arguments) << "profileSharing0806 is on by default in TensorRT 10.0. This flag is deprecated and has no effect." << std::endl; } + else if (featureName == "aliasedPluginIO1003") + { + feat = PreviewFeature::kALIASED_PLUGIN_IO_10_03; + } else { throw std::invalid_argument(std::string("Unknown preview feature: ") + featureName); @@ -2546,7 +2551,8 @@ void BuildOptions::help(std::ostream& os) " --preview=features Specify preview feature to be used by adding (+) or removing (-) preview features from the default" "\n" R"( Preview Features: features ::= [","feature])" "\n" " feature ::= (+|-)flag" "\n" - R"( flag ::= "profileSharing0806")" "\n" + R"( flag ::= "aliasedPluginIO1003")" "\n" + R"( |"profileSharing0806")" "\n" " --builderOptimizationLevel Set the builder optimization level. (default is 3)" "\n" " Higher level allows TensorRT to spend more building time for more optimization options." "\n" " Valid values include integers from 0 to the maximum optimization level, which is currently 5." "\n" diff --git a/samples/common/sampleOptions.h b/samples/common/sampleOptions.h index 4e59da114..bd5fe880d 100644 --- a/samples/common/sampleOptions.h +++ b/samples/common/sampleOptions.h @@ -399,6 +399,7 @@ class TaskInferenceOptions : public Options static void help(std::ostream& out); }; + Arguments argsToArgumentsMap(int32_t argc, char* argv[]); bool parseHelp(Arguments& arguments); diff --git a/samples/python/detectron2/requirements.txt b/samples/python/detectron2/requirements.txt index 0dd8a25b6..d355b4912 100644 --- a/samples/python/detectron2/requirements.txt +++ b/samples/python/detectron2/requirements.txt @@ -1,5 +1,6 @@ onnx==1.16.0 -onnxruntime==1.15.1 +onnxruntime==1.15.1; python_version <= "3.10" +onnxruntime==1.18.1; python_version >= "3.11" Pillow>=10.0.0 git+https://github.com/facebookresearch/detectron2.git git+https://github.com/NVIDIA/TensorRT#subdirectory=tools/onnx-graphsurgeon diff --git a/samples/python/downloader.py b/samples/python/downloader.py index 70bc6bd5f..c4240b3d7 100755 --- a/samples/python/downloader.py +++ b/samples/python/downloader.py @@ -92,17 +92,27 @@ def _downloadFile(path, url): session = requests.Session() retries = Retry(total=10, backoff_factor=0.5) session.mount("http://", HTTPAdapter(max_retries=retries)) - r = session.get(url, stream=True, timeout=30) - - size = int(r.headers.get("content-length", 0)) - from tqdm import tqdm - - progress_bar = tqdm(total=size, unit="iB", unit_scale=True) - with open(path, "wb") as fd: - for chunk in r.iter_content(chunk_size=1024): - progress_bar.update(len(chunk)) - fd.write(chunk) - progress_bar.close() + session.mount("https://", HTTPAdapter(max_retries=retries)) + try: + r = session.get(url, stream=True, timeout=30) + + if r.status_code == 200: + logger.info("Connecting to %s is successful.", url) + + size = int(r.headers.get("content-length", 0)) + from tqdm import tqdm + + progress_bar = tqdm(total=size, unit="iB", unit_scale=True) + with open(path, "wb") as fd: + for chunk in r.iter_content(chunk_size=1024): + progress_bar.update(len(chunk)) + fd.write(chunk) + progress_bar.close() + else: + logger.info("Failed to connect to %s with status code: %s.", url, r.status_code) + + except requests.exceptions.RequestException as e: + logger.debug("Error occurred while requesting connection to %s: %s.", url, e) allGood = True for f in sample_data.files: diff --git a/samples/python/efficientdet/requirements.txt b/samples/python/efficientdet/requirements.txt index 4eef5ebd8..bb83a8daa 100644 --- a/samples/python/efficientdet/requirements.txt +++ b/samples/python/efficientdet/requirements.txt @@ -1,6 +1,8 @@ Pillow>=10.0.0 -onnx==1.14.0 -onnxruntime==1.15.1 +onnx==1.14.0; python_version <= "3.10" +onnx==1.16.1; python_version >= "3.11" +onnxruntime==1.15.1; python_version <= "3.10" +onnxruntime==1.18.1; python_version >= "3.11" tf2onnx==1.8.1 cuda-python==12.2.0; python_version <= "3.10" cuda-python==12.5.0; python_version >= "3.11" diff --git a/samples/python/efficientnet/requirements.txt b/samples/python/efficientnet/requirements.txt index 4dd8fc5f4..73bf53efe 100644 --- a/samples/python/efficientnet/requirements.txt +++ b/samples/python/efficientnet/requirements.txt @@ -1,5 +1,6 @@ Pillow>=10.0.0 -onnx==1.14.0 +onnx==1.14.0; python_version <= "3.10" +onnx==1.16.1; python_version >= "3.11" tensorrt>=7.1.0.0 tf2onnx==1.8.1 cuda-python==12.2.0; python_version <= "3.10" diff --git a/samples/python/non_zero_plugin/requirements.txt b/samples/python/non_zero_plugin/requirements.txt index ae724c401..8f84ea544 100644 --- a/samples/python/non_zero_plugin/requirements.txt +++ b/samples/python/non_zero_plugin/requirements.txt @@ -1,10 +1,12 @@ -cuda-python +cuda-python==12.2.0; python_version <= "3.10" +cuda-python==12.5.0; python_version >= "3.11" cupy-cuda12x torch --extra-index-url https://pypi.ngc.nvidia.com polygraphy colored -numpy==1.23.5; platform_system != "Windows" +numpy==1.23.5; (platform_system != "Windows" and python_version <= "3.10") +numpy==1.26.4; (platform_system != "Windows" and python_version >= "3.11") --extra-index-url https://pypi.ngc.nvidia.com onnx-graphsurgeon pywin32; platform_system == "Windows" diff --git a/samples/python/python_plugin/requirements.txt b/samples/python/python_plugin/requirements.txt index 7cd81a175..4bf8cddac 100644 --- a/samples/python/python_plugin/requirements.txt +++ b/samples/python/python_plugin/requirements.txt @@ -1,4 +1,5 @@ -cuda-python +cuda-python==12.2.0; python_version <= "3.10" +cuda-python==12.5.0; python_version >= "3.11" cupy-cuda12x numba triton; platform_system != "Windows" @@ -6,7 +7,8 @@ torch --extra-index-url https://pypi.ngc.nvidia.com polygraphy colored -numpy==1.23.5; platform_system != "Windows" +numpy==1.23.5; (platform_system != "Windows" and python_version <= "3.10") +numpy==1.26.4; (platform_system != "Windows" and python_version >= "3.11") --extra-index-url https://pypi.ngc.nvidia.com onnx-graphsurgeon pywin32; platform_system == "Windows" diff --git a/samples/python/tensorflow_object_detection_api/README.md b/samples/python/tensorflow_object_detection_api/README.md index b25f1ebfa..de0548e44 100644 --- a/samples/python/tensorflow_object_detection_api/README.md +++ b/samples/python/tensorflow_object_detection_api/README.md @@ -31,6 +31,8 @@ cd /workspace/models/research git checkout 66e22c4 protoc object_detection/protos/*.proto --python_out=. cp object_detection/packages/tf2/setup.py ./ +## Pin pyyaml==6.0.1 to avoid v5.4.1 with known CVEs +sed -i '22i\ '"'"'pyyaml==6.0.1'"'"',' setup.py pip --use-deprecated=legacy-resolver install . ``` diff --git a/samples/python/tensorflow_object_detection_api/requirements.txt b/samples/python/tensorflow_object_detection_api/requirements.txt index b1efdbfb8..eb6d1ce33 100644 --- a/samples/python/tensorflow_object_detection_api/requirements.txt +++ b/samples/python/tensorflow_object_detection_api/requirements.txt @@ -1,5 +1,7 @@ -onnx==1.14.0 -onnxruntime==1.15.1 +onnx==1.14.0; python_version <= "3.10" +onnx==1.16.1; python_version >= "3.11" +onnxruntime==1.15.1; python_version <= "3.10" +onnxruntime==1.18.1; python_version >= "3.11" Pillow>=10.0.0 tf2onnx==1.15.0 pycocotools; platform_system != "Windows" @@ -8,7 +10,7 @@ cuda-python==12.2.0; python_version <= "3.10" cuda-python==12.5.0; python_version >= "3.11" pywin32; platform_system == "Windows" Cython<3.0 -pyyaml==5.3.1 +pyyaml==6.0.1 requests==2.32.2 tqdm==4.66.4 numpy==1.24.4; python_version <= "3.10" diff --git a/samples/sampleDynamicReshape/README.md b/samples/sampleDynamicReshape/README.md index 4c1ced618..4216dbc67 100644 --- a/samples/sampleDynamicReshape/README.md +++ b/samples/sampleDynamicReshape/README.md @@ -202,7 +202,7 @@ The IResizeLayer implements the resize operation on an input tensor. For example: ```bash - ./sample_dynamic_reshape --datadir $TRT_DATADIR/char-rnn --fp16 + ./sample_dynamic_reshape --datadir $TRT_DATADIR/mnist --fp16 ``` 3. Verify that the sample ran successfully. If the sample runs successfully you should see output similar to the following: diff --git a/samples/sampleINT8API/README.md b/samples/sampleINT8API/README.md index 173ea20dd..215796557 100644 --- a/samples/sampleINT8API/README.md +++ b/samples/sampleINT8API/README.md @@ -120,7 +120,7 @@ After the engine has been built, it can be used just like an FP32 engine. For ex 3. Enqueue the inference work and perform actual inference. ``` - context->enqueueV3(input_stream)) + context->enqueueV3(input_stream); ``` 4. Copy data from the device output buffers to the host output buffers. @@ -150,6 +150,8 @@ Set the output type of this layer. Setting the output type forces TensorRT to ch ## Preparing sample data +`ResNet50.onnx` is located in the `data/resnet50` directory. + In addition to the model file and input image, you will need per-tensor dynamic range stored in a text file along with the ImageNet label reference file. The following required files are included in the package and are located in the `data/int8_api` directory. @@ -163,21 +165,6 @@ The ResNet-50 per-tensor dynamic ranges file. `airliner.ppm` The image to be inferred. -1. Download the [ONNX ResNet-50 model](https://github.com/onnx/models/tree/master/vision/classification/resnet/model). - ```bash - wget https://download.onnxruntime.ai/onnx/models/resnet50.tar.gz -O $TRT_DATADIR/int8_api/resnet50.tar.gz - ``` - -2. Unpackage the model file. - ```bash - tar zxvf $TRT_DATADIR/int8_api/resnet50.tar.gz -C $TRT_DATADIR/int8_api/ - ``` - -3. Copy `resnet50/model.onnx` to the `data/int8_api/resnet50.onnx` directory. - ```bash - mv $TRT_DATADIR/int8_api/resnet50/model.onnx $TRT_DATADIR/int8_api/resnet50.onnx - ``` - ## Running the sample 1. Compile the sample by following build instructions in [TensorRT README](https://github.com/NVIDIA/TensorRT/). diff --git a/scripts/stubify.sh b/scripts/stubify.sh index 788d46721..7755c8091 100755 --- a/scripts/stubify.sh +++ b/scripts/stubify.sh @@ -44,6 +44,8 @@ OS=$(lsb_release -si)-$(lsb_release -sr | cut -d '.' -f 1-2) if [ "$OS" = "Ubuntu-22.04" ] ; then EXTRA_NM_FLAG="--without-symbol-versions" +elif [ "$OS" = "Ubuntu-24.04" ] ; then + EXTRA_NM_FLAG="--without-symbol-versions" fi # make stub library diff --git a/tools/Polygraphy/CHANGELOG.md b/tools/Polygraphy/CHANGELOG.md index 50cd8e72a..5196870f0 100644 --- a/tools/Polygraphy/CHANGELOG.md +++ b/tools/Polygraphy/CHANGELOG.md @@ -3,6 +3,11 @@ Dates are in YYYY-MM-DD format. +## v0.49.13 (2024-07-15) +### Added +- Added option to emit logs using python `logging` module. + + ## v0.49.12 (2024-05-28) ### Added - Added `runtime_platform` to `CreateConfig` for TensorRT and corresponding `--runtime-platform` command-line option. diff --git a/tools/Polygraphy/examples/cli/inspect/05_inspecting_inference_outputs/README.md b/tools/Polygraphy/examples/cli/inspect/05_inspecting_inference_outputs/README.md index d93c71609..11aad8dba 100644 --- a/tools/Polygraphy/examples/cli/inspect/05_inspecting_inference_outputs/README.md +++ b/tools/Polygraphy/examples/cli/inspect/05_inspecting_inference_outputs/README.md @@ -28,7 +28,7 @@ The `inspect data` subtool can display information about the ---- onnxrt-runner-N0-07/15/21-10:46:07 (1 iterations) ---- - y [dtype=float32, shape=(1, 1, 2, 2)] | Stats: mean=0.35995, std-dev=0.25784, var=0.066482, median=0.35968, min=0.00011437 at (0, 0, 1, 0), max=0.72032 at (0, 0, 0, 1), avg-magnitude=0.35995 + y [dtype=float32, shape=(1, 1, 2, 2)] | Stats: mean=0.35995, std-dev=0.25784, var=0.066482, median=0.35968, min=0.00011437 at (0, 0, 1, 0), max=0.72032 at (0, 0, 0, 1), avg-magnitude=0.35995, p90=0.62933, p95=0.62933, p99=0.71123 [[[[4.17021990e-01 7.20324516e-01] [1.14374816e-04 3.02332580e-01]]]] ``` diff --git a/tools/Polygraphy/examples/cli/inspect/06_inspecting_input_data/README.md b/tools/Polygraphy/examples/cli/inspect/06_inspecting_input_data/README.md index a37ede3cc..011d2220c 100644 --- a/tools/Polygraphy/examples/cli/inspect/06_inspecting_input_data/README.md +++ b/tools/Polygraphy/examples/cli/inspect/06_inspecting_input_data/README.md @@ -25,7 +25,7 @@ by a data loader. ``` [I] ==== Data (1 iterations) ==== - x [dtype=float32, shape=(1, 1, 2, 2)] | Stats: mean=0.35995, std-dev=0.25784, var=0.066482, median=0.35968, min=0.00011437 at (0, 0, 1, 0), max=0.72032 at (0, 0, 0, 1), avg-magnitude=0.35995 + x [dtype=float32, shape=(1, 1, 2, 2)] | Stats: mean=0.35995, std-dev=0.25784, var=0.066482, median=0.35968, min=0.00011437 at (0, 0, 1, 0), max=0.72032 at (0, 0, 0, 1), avg-magnitude=0.35995, p90=0.62933, p95=0.62933, p99=0.71123 [[[[4.17021990e-01 7.20324516e-01] [1.14374816e-04 3.02332580e-01]]]] ``` diff --git a/tools/Polygraphy/examples/dev/02_extending_polygraphy_run/extension_module/setup.py b/tools/Polygraphy/examples/dev/02_extending_polygraphy_run/extension_module/setup.py index 3150d1a34..043c4f3b9 100644 --- a/tools/Polygraphy/examples/dev/02_extending_polygraphy_run/extension_module/setup.py +++ b/tools/Polygraphy/examples/dev/02_extending_polygraphy_run/extension_module/setup.py @@ -46,6 +46,7 @@ def main(): "polygraphy", # Our included loader needs ONNX-GraphSurgeon to modify the model. "onnx_graphsurgeon", + "numpy<2", ], packages=find_packages(exclude=("tests", "tests.*")), # The format of the entry_points is: diff --git a/tools/Polygraphy/polygraphy/README.md b/tools/Polygraphy/polygraphy/README.md index 3b3d1dc08..cb6a01362 100644 --- a/tools/Polygraphy/polygraphy/README.md +++ b/tools/Polygraphy/polygraphy/README.md @@ -164,6 +164,17 @@ For example: G_LOGGER.module_severity = G_LOGGER.EXTRA_VERBOSE ``` +By default logs are emitted to the stdout/stderr stream. If you would like to have them stored in a file, set the `log_file` property to your log file: +```py +G_LOGGER.log_file = "your_log_file.log" +``` + +If you would like to have logs being emitted to python `logging` module, set the following flag: +```py +G_LOGGER.use_python_logging_system = True +``` + +After that, you can define your logging configuration using the `logging` module. ## Putting It All Together diff --git a/tools/Polygraphy/polygraphy/__init__.py b/tools/Polygraphy/polygraphy/__init__.py index de070e0df..5d3949527 100644 --- a/tools/Polygraphy/polygraphy/__init__.py +++ b/tools/Polygraphy/polygraphy/__init__.py @@ -1,3 +1,3 @@ import polygraphy.config -__version__ = "0.49.12" +__version__ = "0.49.13" diff --git a/tools/Polygraphy/polygraphy/comparator/util.py b/tools/Polygraphy/polygraphy/comparator/util.py index d8791a9b7..5bb5762ab 100644 --- a/tools/Polygraphy/polygraphy/comparator/util.py +++ b/tools/Polygraphy/polygraphy/comparator/util.py @@ -146,7 +146,13 @@ def str_output_stats(output, runner_name=None): ret += f"{runner_name} | Stats: " try: - ret += f"mean={compute_mean(output):.5g}, std-dev={compute_std(output):.5g}, var={compute_variance(output):.5g}, median={compute_median(output):.5g}, min={compute_min(output):.5g} at {compute_argmin(output)}, max={compute_max(output):.5g} at {compute_argmax(output)}, avg-magnitude={compute_average_magnitude(output):.5g}\n" + ret += f"mean={compute_mean(output):.5g}, std-dev={compute_std(output):.5g}, var={compute_variance(output):.5g}, median={compute_median(output):.5g}, min={compute_min(output):.5g} at {compute_argmin(output)}, max={compute_max(output):.5g} at {compute_argmax(output)}, avg-magnitude={compute_average_magnitude(output):.5g}" + + # np.quantile doesn't work with boolean input, so we don't show quantile error if the output type is boolean + if output.dtype == bool: + ret += "\n" + else: + ret += f", p90={compute_quantile(output, 0.9):.5g}, p95={compute_quantile(output, 0.9):.5g}, p99={compute_quantile(output, 0.99):.5g}\n" except Exception as err: G_LOGGER.verbose(f"Could not generate statistics.\nNote: Error was: {err}") ret += "" diff --git a/tools/Polygraphy/polygraphy/datatype/numpy.py b/tools/Polygraphy/polygraphy/datatype/numpy.py index c668a4071..c86a4b7fc 100644 --- a/tools/Polygraphy/polygraphy/datatype/numpy.py +++ b/tools/Polygraphy/polygraphy/datatype/numpy.py @@ -39,7 +39,7 @@ def _get_mapping(): np.uint64: DataType.UINT64, np.uint8: DataType.UINT8, np.bool_: DataType.BOOL, - np.unicode_: DataType.STRING, + np.str_: DataType.STRING, } return {np.dtype(key): val for key, val in DATATYPE_FROM_NUMPY.items()} diff --git a/tools/Polygraphy/polygraphy/logger/logger.py b/tools/Polygraphy/polygraphy/logger/logger.py index 7260ee9ee..9b4a9d219 100644 --- a/tools/Polygraphy/polygraphy/logger/logger.py +++ b/tools/Polygraphy/polygraphy/logger/logger.py @@ -17,6 +17,7 @@ import copy import enum import functools +import logging import os import sys import time @@ -239,6 +240,15 @@ def __init__( This is converted to a ``SeverityTrie`` on assignment. Defaults to G_LOGGER.INFO. """ + self._use_python_logging_system = False + """ + A flag indicating whether to use the Python `logging` module for log emission. + By default, logs are emitted to `stdout` or `stderr`. When this flag is set to `True`, + the logger uses the Python `logging` module instead of `stdout`/`stderr`. + This allows logs to be integrated into a unified logging system which can be helpful + in advanced cases like using multiprocessing or when the user wants one logging system + to manage Polygraphy and other libraries logs. + """ @property def log_file(self): @@ -286,6 +296,17 @@ def severity(self, value): ) self.module_severity = value + @property + def use_python_logging_system(self): + return self._use_python_logging_system + + @use_python_logging_system.setter + def use_python_logging_system(self, value): + self._use_python_logging_system = value + if value: + self.python_logger = logging.getLogger("Polygraphy") + self.severity_level_mapping = { Logger.ULTRA_VERBOSE : 2, Logger.SUPER_VERBOSE: 4, Logger.EXTRA_VERBOSE: 6 } + def module_path(self, path): """ Converts a given path to a path relative to the Polygraphy root module. @@ -459,7 +480,12 @@ def should_log(message): self._log_file.write(message + "\n") self._log_file.flush() - print(message, file=sys.stdout if severity < Logger.CRITICAL else sys.stderr) + if self._use_python_logging_system: + # python logging system does not handle negative levels, map them to positive values + level = severity if severity > 0 else self.severity_level_mapping[severity] + self.python_logger.log(level=level, msg=message) + else: + print(message, file=sys.stdout if severity < Logger.CRITICAL else sys.stderr) def backtrace(self, depth=0, limit=None, severity=ERROR): limit = ( diff --git a/tools/Polygraphy/tests/conftest.py b/tools/Polygraphy/tests/conftest.py index 610ed04ae..38a4c5884 100644 --- a/tools/Polygraphy/tests/conftest.py +++ b/tools/Polygraphy/tests/conftest.py @@ -18,6 +18,7 @@ import copy import ctypes.util import glob +import logging import os import subprocess as sp import sys @@ -195,3 +196,20 @@ def nvinfer_lean_path(): return path assert False, "Could not find nvinfer_lean!" + + +@pytest.fixture() +def tmp_python_log_file(tmp_path): + # backup original logging configuration + orig_handlers = logging.root.handlers[:] + orig_level = logging.root.level + logging.root.handlers = [] + tmp_log_file = tmp_path / "test.log" + # setup logging to file + logging.basicConfig(filename=tmp_log_file, level=0) + try: + yield tmp_log_file + finally: + # revert back original configuration + logging.root.handlers = orig_handlers + logging.root.level = orig_level diff --git a/tools/Polygraphy/tests/logger/test_logger.py b/tools/Polygraphy/tests/logger/test_logger.py index 226740e01..77e83232e 100644 --- a/tools/Polygraphy/tests/logger/test_logger.py +++ b/tools/Polygraphy/tests/logger/test_logger.py @@ -16,9 +16,12 @@ # import inspect +import logging import pytest + from polygraphy import util +from polygraphy.exception.exception import PolygraphyException from polygraphy.logger.logger import Logger, SeverityTrie @@ -72,6 +75,46 @@ def callback(module_severity): assert num_times_called == 3 assert num_times_called == 4 + @pytest.mark.serial + def test_use_python_logging_system(self, tmp_python_log_file): + logger = Logger(severity=Logger.ULTRA_VERBOSE) + logger.use_python_logging_system = True + # add custom Polygraphy levels + logging.addLevelName(2, "ULTRA_VERBOSE") + logging.addLevelName(4, "SUPER_VERBOSE") + logging.addLevelName(6, "EXTRA_VERBOSE") + logging.addLevelName(22, "START") + logging.addLevelName(28, "FINISH") + + # emit logs + logger.ultra_verbose("ultra verbose") + logger.super_verbose("super verbose") + logger.extra_verbose("extra verbose") + logger.verbose("verbose") + logger.info("info") + logger.start("start") + logger.finish("finish") + logger.warning("warning") + logger.error("error") + with pytest.raises(PolygraphyException): + logger.critical("critical") + + # verify logs written in the log file + with tmp_python_log_file.open() as fp: + log_messages = fp.read() + + assert log_messages == """\ +ULTRA_VERBOSE:Polygraphy:[U] ultra verbose +SUPER_VERBOSE:Polygraphy:[S] super verbose +EXTRA_VERBOSE:Polygraphy:[X] extra verbose +DEBUG:Polygraphy:[V] verbose +INFO:Polygraphy:[I] info +START:Polygraphy:[I] start +FINISH:Polygraphy:[I] finish +WARNING:Polygraphy:[W] warning +ERROR:Polygraphy:[E] error +CRITICAL:Polygraphy:[!] critical +""" class TestSeverityTrie: @pytest.mark.parametrize(