This is a fork of tkDNN for the project CapeReviso.

• Added scripts, parameters and code to run it with IDS cameras as well as Logitech Brios using a systemd
• implement continuous exposure correction
• calculate privacy friendly background images
• json output with unix time of each frame
• queuing of images for for optimal performance in a live setup
• end recording on day change, for having one file per day

• main - still on TensorRT 7 for old devices
• tensorrt8-branch - currect branch for new installed devices
• deepsort - prototype for adding deepsort for subsequent tracking

tkDNN is a Deep Neural Network library built with cuDNN and tensorRT primitives, specifically thought to work on NVIDIA Jetson Boards. It has been tested on TK1(branch cudnn2), TX1, TX2, AGX Xavier, Nano and several discrete GPUs. The main goal of this project is to exploit NVIDIA boards as much as possible to obtain the best inference performance. It does not allow training.

If you use tkDNN in your research, please cite the following paper. For use in commercial solutions, write at gattifrancesco@hotmail.it and micaela.verucchi@unimore.it or refer to https://hipert.unimore.it/ .

@inproceedings{verucchi2020systematic,
  title={A Systematic Assessment of Embedded Neural Networks for Object Detection},
  author={Verucchi, Micaela and Brilli, Gianluca and Sapienza, Davide and Verasani, Mattia and Arena, Marco and Gatti, Francesco and Capotondi, Alessandro and Cavicchioli, Roberto and Bertogna, Marko and Solieri, Marco},
  booktitle={2020 25th IEEE International Conference on Emerging Technologies and Factory Automation (ETFA)},
  volume={1},
  pages={937--944},
  year={2020},
  organization={IEEE}
}

• Support to sematic segmentation README
• Support 2D/3D Object Detection and Tracking README

• Support to sematic segmentation on cuda 11
• Support to TensorRT8.

TensorRT8 (and therefore Jetpack 4.6) is currently supported only on the branch tensort8 due to performance issue with TensorRT8). We will merge it to the master as soon as those issues are fixed (probably in future minor releases).

Inference FPS of yolov4 with tkDNN, average of 1200 images with the same dimension as the input size, on

• RTX 2080Ti (CUDA 10.2, TensorRT 7.0.0, Cudnn 7.6.5);
• Xavier AGX, Jetpack 4.3 (CUDA 10.0, CUDNN 7.6.3, tensorrt 6.0.1 );
• Xavier NX, Jetpack 4.4 (CUDA 10.2, CUDNN 8.0.0, tensorrt 7.1.0 ).
• Tx2, Jetpack 4.2 (CUDA 10.0, CUDNN 7.3.1, tensorrt 5.0.6 );
• Jetson Nano, Jetpack 4.4 (CUDA 10.2, CUDNN 8.0.0, tensorrt 7.1.0 ).

Results for COCO val 2017 (5k images), on RTX 2080Ti, with conf threshold=0.001

• tkDNN
  • Index
  • Dependencies
  • How to compile this repo
  • Workflow
  • Exporting weights
  • Run the demos
  • tkDNN on Windows 10 or Windows 11
  • Existing tests and supported networks
  • References

This branch works on every NVIDIA GPU that supports the following (latest tested) dependencies:

• CUDA 11.3 (or >= 10.2)
• cuDNN 8.2.1 (or >= 8.0.4)
• TensorRT 8.0.3 (or >=7.2)
• OpenCV 4.5.4 (or >=4)
• cmake 3.21 (or >= 3.15)
• yaml-cpp 0.5.2
• eigen3 3.3.4
• curl 7.58

sudo apt install libyaml-cpp-dev curl libeigen3-dev

To compile and install OpenCV4 with contrib us the script install_OpenCV4.sh. It will download and compile OpenCV in Download folder.

bash scripts/install_OpenCV4.sh

If you have OpenCV compiled with cuda and contrib and want to use it with tkDNN pass ENABLE_OPENCV_CUDA_CONTRIB=ON flag when compiling tkDBB . If the flag is not passed,the preprocessing of the networks is computed on the CPU, otherwise on the GPU. In the latter case some milliseconds are saved in the end-to-end latency.

Build with cmake. If using Ubuntu 18.04 a new version of cmake is needed (3.15 or above). On both linux and windows ,the CMAKE_BUILD_TYPE variable needs to be defined as either Release or Debug.

git clone https://github.com/ceccocats/tkDNN
cd tkDNN
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -G"Ninja" .. 
ninja

Steps needed to do inference on tkDNN with a custom neural network.

• Build and train a NN model with your favorite framework.
• Export weights and bias for each layer and save them in a binary file (one for layer).
• Export outputs for each layer and save them in a binary file (one for layer).
• Create a new test and define the network, layer by layer using the weights extracted and the output to check the results.
• Do inference.

For specific details on how to export weights see HERE.

tkDNN implement and easy parser for darknet cfg files, a network can be converted with tk::dnn::darknetParser:

// example of parsing yolo4
tk::dnn::Network *net = tk::dnn::darknetParser("yolov4.cfg", "yolov4/layers", "coco.names");
net->print();

All models from darknet are now parsed directly from cfg, you still need to export the weights with the descripted tools in the previus section.

This is an example using yolov4.

To run the an object detection first create the .rt file by running:

rm yolo4_fp32.rt        # be sure to delete(or move) old tensorRT files
./test_yolo4            # run the yolo test (is slow)

If you get problems in the creation, try to check the error activating the debug of TensorRT in this way:

cmake .. -DDEBUG=True
make

Once you have succesfully created your rt file, run the demo:

./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y

In general the demo program takes 6 parameters:

./demo <network-rt-file> <path-to-video> <kind-of-network> <number-of-classes> <n-batches> <show-flag> <save-flag> <http-stream-port>

where

• <network-rt-file> is the rt file generated by a test
• <<path-to-video> is the path to a video file or a camera input
• <kind-of-network> is the type of network. Thee types are currently supported: y (YOLO family), c (CenterNet family) and m (MobileNet-SSD family)
• <number-of-classes>is the number of classes the network is trained on
• <n-batches> number of batches to use in inference (N.B. you should first export TKDNN_BATCHSIZE to the required n_batches and create again the rt file for the network).
• <show-flag> if set to 0 the demo will not show the visualization.
• <save-flag> if set to 0 the results will be saved into result.mp4 (if n-batches ==1) and if set to 1 then the results will not be saved.
• <http-stream-port> if set to 0 then http stream will be off but if port number is given eg: 8090 then the stream can seen the results in https://localhost:8090
• <extyolo flag> if set to 1 then yolo like coordinates of the bounding boxes will be printed on the terminal

N.b. By default it is used FP32 inference

For specific details on how to run:

• 2D object detection demos, details on FP16, INT8 and batching see HERE.
• segmentation demos see HERE.
• 2D/3D object detection and tracking demos see HERE.
• mAP demo to evaluate 2D object detectors see HERE.

For specific details on how to run tkDNN on Windows 10/11 see HERE.

1. Redmon, Joseph, and Ali Farhadi. "YOLO9000: better, faster, stronger." Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.
2. Redmon, Joseph, and Ali Farhadi. "Yolov3: An incremental improvement." arXiv preprint arXiv:1804.02767 (2018).
3. Yu, Fisher, et al. "Deep layer aggregation." Proceedings of the IEEE conference on computer vision and pattern recognition. 2018.
4. Zhou, Xingyi, Dequan Wang, and Philipp Krähenbühl. "Objects as points." arXiv preprint arXiv:1904.07850 (2019).
5. Sandler, Mark, et al. "Mobilenetv2: Inverted residuals and linear bottlenecks." Proceedings of the IEEE conference on computer vision and pattern recognition. 2018.
6. He, Kaiming, et al. "Deep residual learning for image recognition." Proceedings of the IEEE conference on computer vision and pattern recognition. 2016.
7. Wang, Chien-Yao, et al. "CSPNet: A New Backbone that can Enhance Learning Capability of CNN." arXiv preprint arXiv:1911.11929 (2019).
8. Bochkovskiy, Alexey, Chien-Yao Wang, and Hong-Yuan Mark Liao. "YOLOv4: Optimal Speed and Accuracy of Object Detection." arXiv preprint arXiv:2004.10934 (2020).
9. Bochkovskiy, Alexey, "Yolo v4, v3 and v2 for Windows and Linux" (https://github.com/AlexeyAB/darknet)
10. Wang, Chien-Yao, Alexey Bochkovskiy, and Hong-Yuan Mark Liao. "Scaled-YOLOv4: Scaling Cross Stage Partial Network." arXiv preprint arXiv:2011.08036 (2020).
11. Zhuang, Juntang, et al. "ShelfNet for fast semantic segmentation." Proceedings of the IEEE International Conference on Computer Vision Workshops. 2019.
12. Zhou, Xingyi, Vladlen Koltun, and Philipp Krähenbühl. "Tracking objects as points." European Conference on Computer Vision. Springer, Cham, 2020.