Merge pull request #14 from NVIDIA-ISAAC-ROS/release-dp

Isaac ROS 0.10.0 (DP)

Author: hemalshahNV

.gitattributes

@@ -8,19 +8,13 @@
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.tar filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
+
 # Documents
 *.pdf filter=lfs diff=lfs merge=lfs -text
-# Numpy data
-*.npy filter=lfs diff=lfs merge=lfs -text
-# Debian package
-*.deb filter=lfs diff=lfs merge=lfs -text
 
 # Shared libraries
 *.so filter=lfs diff=lfs merge=lfs -text
 *.so.* filter=lfs diff=lfs merge=lfs -text
 
-# PCD files
-*.pcd filter=lfs diff=lfs merge=lfs -text
-
 # Model files
 *.onnx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,60 @@
+# Preparing Deep Learning Models for Isaac ROS
+
+## Obtaining a Pre-trained Model from NGC
+The NVIDIA GPU Cloud hosts a [catalog](https://catalog.ngc.nvidia.com/models) of Deep Learning pre-trained models that are available for your development.
+
+1. Use the **Search Bar** to find a pre-trained model that you are interested in working with.
+
+2. Click on the model's card to view an expanded description, and then click on the **File Browser** tab along the navigation bar.
+
+3. Using the **File Browser**, find a deployable `.etlt` file for the model you are interested in.
+
+    > **Note:** The `.etlt` file extension indicates that this model has pre-trained but **encrypted** weights, which means one needs to use the `tao-converter` utility to decrypt the model, as described [below](#using-tao-converter-to-decrypt-the-encrypted-tlt-model-etlt-format).
+
+4. Under the **Actions** heading, click on the **...** icon for the file you selected in the previous step, and then click **Copy `wget` command**.
+5. **Paste** the copied command into a terminal to download the model in the current working directory.
+
+## Using `tao-converter` to decrypt the Encrypted TLT Model (`.etlt`) Format
+As discussed above, models distributed with the `.etlt` file extension are encrypted and must be decrypted before use via NVIDIA's [`tao-converter`](https://developer.nvidia.com/tao-toolkit-get-started).
+
+`tao-converter` is already included in the Docker images available as part of the standard [Isaac ROS Development Environment](https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_common/docs/dev-env-setup.md).
+
+The per-platform installation paths are described below:
+
+| Platform        | Installation Path                                             | Symlink Path                        |
+| --------------- | ------------------------------------------------------------- | ----------------------------------- |
+| x86_64          | `/opt/nvidia/tao/tao-converter-x86-tensorrt8.0/tao-converter` | **`/opt/nvidia/tao/tao-converter`** |
+| Jetson(aarch64) | `/opt/nvidia/tao/jp5`                                         | **`/opt/nvidia/tao/tao-converter`** |
+
+
+### Converting `.etlt` to a TensorRT Engine Plan
+Here are some examples for generating the TensorRT engine file using `tao-converter`. In this example, we will use the [`PeopleSemSegnet Shuffleseg` model](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/tao/models/peoplesemsegnet/files?version=deployable_shuffleseg_unet_v1.0):
+
+#### Generate an engine file for the `fp16` data type:
+   ```bash
+   mkdir -p /workspaces/isaac_ros-dev/models && \
+      /opt/nvidia/tao/tao-converter -k tlt_encode -d 3,544,960 -p input_2:0,1x3x544x960,1x3x544x960,1x3x544x960 -t fp16 -e /workspaces/isaac_ros-dev/models/peoplesemsegnet_shuffleseg.engine -o argmax_1 peoplesemsegnet_shuffleseg_etlt.etlt
+   ```
+   > **Note:** The specific values used in the command above are retrieved from the **PeopleSemSegnet** page under the **Overview** tab. The model input node name and output node name can be found in `peoplesemsegnet_shuffleseg_cache.txt` from `File Browser`. The output file is specified using the `-e` option. The tool needs write permission to the output directory.
+   >
+   > A detailed explanation of the input parameters is available [here](https://docs.nvidia.com/tao/tao-toolkit/text/tensorrt.html#running-the-tao-converter).
+
+#### Generate an engine file for the data type `int8`:
+   
+   Create the models directory:
+   ```bash
+   mkdir -p /workspaces/isaac_ros-dev/models
+   ```
+
+   Download the calibration cache file:  
+   > **Note:** Check the model's page on NGC for the latest `wget` command.
+
+   ```bash
+   wget https://api.ngc.nvidia.com/v2/models/nvidia/tao/peoplesemsegnet/versions/deployable_shuffleseg_unet_v1.0/files/peoplesemsegnet_shuffleseg_cache.txt
+   ```
+
+   ```bash
+   /opt/nvidia/tao/tao-converter -k tlt_encode -d 3,544,960 -p input_2:0,1x3x544x960,1x3x544x960,1x3x544x960 -t int8 -c peoplesemsegnet_shuffleseg_cache.txt -e /workspaces/isaac_ros-dev/models/peoplesemsegnet_shuffleseg.engine -o argmax_1 peoplesemsegnet_shuffleseg_etlt.etlt
+   ```
+
+   > **Note**: The calibration cache file (specified using the `-c` option) is required to generate the `int8` engine file. This file is provided in the **File Browser** tab of the model's page on NGC.

docs/model-preparation.md

@@ -0,0 +1,41 @@
+# Isaac ROS Triton and TensorRT Nodes for DNN Inference
+
+NVIDIA's Isaac ROS suite of packages provides two separate nodes for performing DNN inference: Triton and TensorRT. 
+
+Our benchmarks show comparable performance and inference speed with both nodes, so a decision should be based on other characteristics of the overall model being deployed.
+
+## NVIDIA Triton
+The NVIDIA Triton Inference Server is an [open-source inference serving software](https://developer.nvidia.com/nvidia-triton-inference-server) that provides a uniform interface for deploying AI models. Crucially, Triton supports a wide array of compute devices like NVIDIA GPUs and both x86 and ARM CPUs, and also operates with all major frameworks such as TensorFlow, TensorRT, and PyTorch. 
+
+Because Triton can take advantage of additional compute devices beyond just the GPU, Triton can be a better choice in situations where there is GPU resource contention from other model inference or processing tasks. However, in order to provide for this flexibility, Triton requires the creation of a model repository and additional configuration files before deployment.
+
+## NVIDIA TensorRT
+NVIDIA TensorRT is a specific CUDA-based, on-GPU inference framework that performs a number of optimizations to deliver extremely performant model execution. TensorRT only supports ONNX and TensorRT Engine Plans, providing less flexibility than Triton but also requiring less initial configuration. 
+
+## Using either Triton or TensorRT Nodes
+Both nodes use the Isaac ROS [Tensor List message](https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_common/blob/main/isaac_ros_tensor_list_interfaces/msg/TensorList.msg) for input data and output inference result. 
+
+Users can either prepare a custom model or download pre-trained models from NGC as described [here](./model-preparation.md#obtaining-a-pre-trained-model-from-ngc). Models should be converted to the TensorRT Engine File format using the `tao-converter` tool as described [here](./model-preparation.md#using-tao-converter-to-decrypt-the-encrypted-tlt-model-etlt-format).
+
+> **Note:** While the TensorRT node can automatically convert ONNX plans to the TensorRT Engine Plan format if configured to use a `.onnx` file, this conversion step will considerably extend the node's per-launch initial setup time. 
+> 
+> As a result, we recommend converting any ONNX models to TensorRT Engine Plans first, and configuring the TensorRT node to use the Engine Plan instead.
+
+
+## Pre- and Post-Processing Nodes
+In order to be a useful component of a ROS graph, both Isaac ROS Triton and TensorRT inference nodes will require application-specific `pre-processor` (`encoder`) and `post-processor` (`decoder`) nodes to handle type conversion and other necessary steps. 
+
+A `pre-processor` node should take in a ROS2 message, perform the pre-processing steps dictated by the model, and then convert the data into an Isaac ROS Tensor List message. For example, a `pre-processor` node could resize an image, normalize it, and then convert it into a Tensor List. 
+
+A `post-processor` node should be used to convert the Isaac ROS Tensor List output of the model inference into a useful ROS2 message. For example, a `post-processor` node may perform argmax to identify the class label from a classification problem. 
+
+<div align="center"> 
+
+![Using TensorRT or Triton](../resources/pipeline.png "Using TensorRT or Triton") 
+
+</div>
+
+## Further Reading
+For more documentation on Triton, see [here](https://developer.nvidia.com/nvidia-triton-inference-server). 
+
+For more documentation on TensorRT, see [here](https://developer.nvidia.com/tensorrt). 

docs/tensorrt-and-triton-info.md

@@ -0,0 +1,18 @@
+# DNN Inference Troubleshooting
+## Seeing operation failed followed by the process dying
+One cause of this issue is when the GPU being used does not have enough memory to run the model. For example, DOPE may require up to 6GB of VRAM to operate, depending on the application.
+
+### Symptom
+```
+[component_container_mt-1] 2022-06-27 08:35:37.518 ERROR extensions/tensor_ops/Reshape.cpp@71: reshape tensor failed.
+[component_container_mt-1] 2022-06-27 08:35:37.518 ERROR extensions/tensor_ops/TensorOperator.cpp@151: operation failed.
+[component_container_mt-1] 2022-06-27 08:35:37.518 ERROR gxf/std/entity_executor.cpp@200: Entity with 102 not found!
+[component_container_mt-1] INFO: infer_simple_runtime.cpp:69 TrtISBackend id:164 initialized model: Ketchup
+[component_container_mt-1] 2022-06-27 08:35:37.518 WARN  gxf/std/greedy_scheduler.cpp@221: Error while executing entity 87 named 'VERAGYEWGZ_reshaper': GXF_FAILURE
+[component_container_mt-1] [ERROR] [1656318937.518424053] [dope_encoder]: [NitrosPublisher] Vault ("vault/vault", eid=102) was stopped. The graph may have been terminated due to an error.
+[component_container_mt-1] terminate called after throwing an instance of 'std::runtime_error'
+[component_container_mt-1]   what():  [NitrosPublisher] Vault ("vault/vault", eid=102) was stopped. The graph may have been terminated due to an error.
+[ERROR] [component_container_mt-1]: process has died [pid 13378, exit code -6, cmd '/opt/ros/humble/install/lib/rclcpp_components/component_container_mt --ros-args -r __node:=dope_container -r __ns:=/'].
+```
+### Solution
+Try using the Isaac ROS TensorRT node or the Isaac ROS Triton node with the TensorRT backend instead. Otherwise, a discrete GPU with more VRAM may be required.

docs/troubleshooting.md

@@ -1,13 +1,13 @@
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2021-2022, NVIDIA CORPORATION.  All rights reserved.
 #
 # NVIDIA CORPORATION and its licensors retain all intellectual property
 # and proprietary rights in and to this software, related documentation
 # and any modifications thereto.  Any use, reproduction, disclosure or
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-cmake_minimum_required(VERSION 3.5)
-project(isaac_ros_dnn_encoders)
+cmake_minimum_required(VERSION 3.8)
+project(isaac_ros_dnn_encoders LANGUAGES C CXX)
 
 # Default to C++17
 if(NOT CMAKE_CXX_STANDARD)
@@ -24,18 +24,31 @@ if(NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
 endif()
 message( STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}" )
 
+execute_process(COMMAND uname -m COMMAND tr -d '\n'
+  OUTPUT_VARIABLE ARCHITECTURE
+)
+message( STATUS "Architecture: ${ARCHITECTURE}" )
+
 find_package(ament_cmake_auto REQUIRED)
 ament_auto_find_build_dependencies()
 
+# Find VPI dependency
+find_package(vpi REQUIRED)
+
 # DNN Image Encoder Node
 ament_auto_add_library(dnn_image_encoder_node SHARED src/dnn_image_encoder_node.cpp)
 target_compile_definitions(dnn_image_encoder_node
   PRIVATE "COMPOSITION_BUILDING_DLL"
 )
-rclcpp_components_register_nodes(dnn_image_encoder_node "isaac_ros::dnn_inference::DnnImageEncoderNode")
-set(node_plugins "${node_plugins}isaac_ros::dnn_inference::DnnImageEncoderNode;$<TARGET_FILE:dnn_image_encoder_node>\n")
+target_link_libraries(dnn_image_encoder_node)
+rclcpp_components_register_nodes(dnn_image_encoder_node "nvidia::isaac_ros::dnn_inference::DnnImageEncoderNode")
+set(node_plugins "${node_plugins}nvidia::isaac_ros::dnn_inference::DnnImageEncoderNode;$<TARGET_FILE:dnn_image_encoder_node>\n")
 
-ament_auto_add_executable("dnn_image_encoder" src/dnn_image_encoder_main.cpp)
+# Install config directory
+install(
+  DIRECTORY config
+  DESTINATION share/${PROJECT_NAME}
+)
 
 install(TARGETS dnn_image_encoder_node
   ARCHIVE DESTINATION lib
@@ -52,6 +65,7 @@ if(BUILD_TESTING)
   ament_lint_auto_find_test_dependencies()
 
   find_package(launch_testing_ament_cmake REQUIRED)
+  add_launch_test(test/isaac_ros_dnn_image_encoder_test.py)
 endif()
 
 ament_auto_package(INSTALL_TO_SHARE)