diff --git a/.gitignore b/.gitignore index c1d362c..22f7f94 100644 --- a/.gitignore +++ b/.gitignore @@ -19,4 +19,6 @@ demo/BDD100K_val cmake-build-minsizerel/* scripts/COCO_val2017/* scripts/COCO_val2017.zip -scripts/all_labels.txt \ No newline at end of file +scripts/all_labels.txt +/cmake/cuda_script +/cmake-build-debug/ diff --git a/CMakeLists.txt b/CMakeLists.txt index 877b506..c29e987 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,15 +1,69 @@ cmake_minimum_required(VERSION 3.15) - -project (tkDNN) +project(tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) -if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations") -endif() -if(WIN32) set(CMAKE_CXX_STANDARD 14) -set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") + +option(ENABLE_OPENCV_CUDA_CONTRIB "Enable OpenCV CUDA Contrib" OFF ) + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Release" CACHE STRING "default build" FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +find_package(CUDA 9.0 REQUIRED) +if (CUDA_FOUND) + set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required + execute_process(COMMAND "rm ${OUTPUTFILE}") + set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) + execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) + execute_process(COMMAND ${OUTPUTFILE} + RESULT_VARIABLE CUDA_RETURN_CODE + OUTPUT_VARIABLE ARCH) + + if(${CUDA_RETURN_CODE} EQUAL 0) + set(CUDA_SUCCESS "TRUE") + else() + set(CUDA_SUCCESS "FALSE") + endif() + + if (${CUDA_SUCCESS}) + message(STATUS "CUDA Architecture: ${ARCH}") + message(STATUS "CUDA Version: ${CUDA_VERSION_STRING}") + message(STATUS "CUDA Path: ${CUDA_TOOLKIT_ROOT_DIR}") + message(STATUS "CUDA Libararies: ${CUDA_LIBRARIES}") + message(STATUS "CUDA Performance Primitives: ${CUDA_npp_LIBRARY}") + set(CUDA_NVCC_FLAGS "${ARCH}") + else() + message(WARNING ${ARCH}) + endif() +endif() + +SET(CUDA_SEPARABLE_COMPILATION ON) + +if(UNIX) + if(CMAKE_BUILD_TYPE MATCHES Release) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) + endif() + + if(CMAKE_BUILD_TYPE MATCHES Debug) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wno-deprecated-declarations -Wno-unused-variable -g3") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) + endif() +endif() + +if(WIN32) + if(CMAKE_BUILD_TYPE MATCHES Release) + set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc /MD") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) + endif() + + if(CMAKE_BUILD_TYPE MATCHES Debug) + set(CMAKE_CXX_FLAGS "/Od /FS /EHsc /MDd") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) + endif() set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) endif(WIN32) + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/tkDNN) # project specific flags @@ -18,7 +72,7 @@ if(DEBUG) endif() if(TKDNN_PATH) - message("SET TKDNN_PATH:"${TKDNN_PATH}) + message("SET TKDNN_PATH:" ${TKDNN_PATH}) add_definitions(-DTKDNN_PATH="${TKDNN_PATH}") else() add_definitions(-DTKDNN_PATH="${CMAKE_CURRENT_SOURCE_DIR}") @@ -28,20 +82,21 @@ endif() #------------------------------------------------------------------------------- # CUDA #------------------------------------------------------------------------------- -find_package(CUDA 9.0 REQUIRED) -SET(CUDA_SEPARABLE_COMPILATION ON) -#set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) +set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}" --compiler-options '-fPIC') + find_package(CUDNN REQUIRED) include_directories(${CUDNN_INCLUDE_DIR}) +find_package(yaml-cpp REQUIRED) + # compile -file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu") +file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" "src/pluginsRT/*.cpp") cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${CUDNN_INCLUDE_DIRS}) cuda_add_library(kernels SHARED ${tkdnn_CUSRC}) -target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES}) +target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES} yaml-cpp) + #------------------------------------------------------------------------------- @@ -53,12 +108,23 @@ include_directories(${EIGEN3_INCLUDE_DIR}) find_package(OpenCV REQUIRED) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOPENCV") +if(ENABLE_OPENCV_CUDA_CONTRIB) + if (OpenCV_FOUND) + find_package(OpenCV COMPONENTS cudawarping cudaarithm) + if(OpenCV_cudawarping_FOUND AND OpenCV_cudaarithm_FOUND) + add_compile_definitions(OPENCV_CUDACONTRIB) + message("OpenCV Cuda Contrib modules found") + else() + message("OpenCV Cuda Contrib modules not found") + set(ENABLE_OPENCV_CUDA_CONTRIB OFF) + endif() + endif() +endif() # if(OpenCV_CUDA_VERSION) # add_compile_definitions(OPENCV_CUDACONTRIB) # endif() # gives problems in cross-compiling, probably malformed cmake config -find_package(yaml-cpp REQUIRED) #------------------------------------------------------------------------------- # Build Libraries @@ -69,7 +135,7 @@ set(tkdnn_LIBS kernels ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRAR set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${OPENCV_INCLUDE_DIRS} ${NVINFER_INCLUDES}) add_library(tkDNN SHARED ${tkdnn_SRC}) -target_link_libraries(tkDNN ${tkdnn_LIBS}) +target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRARIES}) #static #add_library(tkDNN_static STATIC ${tkdnn_SRC}) @@ -143,6 +209,14 @@ target_link_libraries(test_shelfnet_mapillary tkDNN) add_executable(test_shelfnet_coco tests/shelfnet/shelfnet_coco.cpp) target_link_libraries(test_shelfnet_coco tkDNN) +# MONODEPTH2 +add_executable(test_monodepth2_640 tests/monodepth2/monodepth2_640.cpp) +target_link_libraries(test_monodepth2_640 tkDNN) + +add_executable(test_monodepth2_1024 tests/monodepth2/monodepth2_1024.cpp) +target_link_libraries(test_monodepth2_1024 tkDNN) + + # DEMOS add_executable(test_rtinference tests/test_rtinference/rtinference.cpp) target_link_libraries(test_rtinference tkDNN) @@ -162,6 +236,9 @@ target_link_libraries(demoTracker tkDNN) add_executable(seg_demo demo/demo/seg_demo.cpp) target_link_libraries(seg_demo tkDNN) +add_executable(demoDepth demo/demo/demoDepth.cpp) +target_link_libraries(demoDepth tkDNN) + #------------------------------------------------------------------------------- # Install #------------------------------------------------------------------------------- @@ -171,7 +248,7 @@ target_link_libraries(seg_demo tkDNN) #endif() message("install dir:" ${CMAKE_INSTALL_PREFIX}) install(DIRECTORY include/ DESTINATION include/) -install(TARGETS tkDNN kernels DESTINATION lib) +install(TARGETS tkDNN DESTINATION lib) install(TARGETS test_simple test_mnist test_mnistRT test_rtinference demo map_demo DESTINATION bin) install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/" # source directory DESTINATION "share/tkDNN/cmake/" # target directory diff --git a/README.md b/README.md index ddfd4ef..825c00b 100644 --- a/README.md +++ b/README.md @@ -23,9 +23,11 @@ If you use tkDNN in your research, please cite the [following paper](https://iee - [x] Support 2D/3D Object Detection and Tracking [README](docs/README_2d3dtracking.md) #### 24 November 2021 - [x] Support to sematic segmentation on cuda 11 -- [x] Support to TensorRT8 (thanks to [Harshvardhan Chandirasekar](https://github.com/perseusdg)). +- [x] Support to TensorRT8. (thanks to [Harshvardhan Chandirasekar](https://github.com/perseusdg)) +#### 30 March 2022 +- [x] Support to monocular depth esitmation [README](docs/README_depth.md) (thanks to [Harshvardhan Chandirasekar](https://github.com/perseusdg)) + -TensorRT8 (and therefore Jetpack 4.6) is currently supported only on the branch tensorrt8 due to [performance issue with TensorRT8](https://docs.nvidia.com/deeplearning/tensorrt/release-notes/tensorrt-8.html)). We will merge it to the master as soon as those issues are fixed (probably in future minor releases). ## FPS Results Inference FPS of yolov4 with tkDNN, average of 1200 images with the same dimension as the input size, on @@ -80,17 +82,17 @@ Results for COCO val 2017 (5k images), on RTX 2080Ti, with conf threshold=0.001 - [Workflow](#workflow) - [Exporting weights](#exporting-weights) - [Run the demos](#run-the-demos) - - [tkDNN on Windows 10 (experimental)](#tkdnn-on-windows-10-experimental) + - [tkDNN on Windows 10 or Windows 11](#tkdnn-on-windows-10-or-windows-11) - [Existing tests and supported networks](#existing-tests-and-supported-networks) - [References](#references) ## Dependencies This branch works on every NVIDIA GPU that supports the following (latest tested) dependencies: -* CUDA 11.0 (or >= 10) [the segmentation only works with CUDA 10 for now] -* cuDNN 8.0.4 (or >= 7.3) -* TensorRT 7.2.0 (or >=5) -* OpenCV 4.5.2 (or >=4) +* 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 @@ -106,16 +108,18 @@ To compile and install OpenCV4 with contrib us the script ```install_OpenCV4.sh` ``` bash scripts/install_OpenCV4.sh ``` -When using openCV not compiled with contrib, comment the definition of OPENCV_CUDACONTRIBCONTRIB in include/tkDNN/DetectionNN.h. When commented, 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. +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. ## How to compile this repo -Build with cmake. If using Ubuntu 18.04 a new version of cmake is needed (3.15 or above). +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 .. +cmake -DCMAKE_BUILD_TYPE=Release .. make ``` @@ -136,14 +140,15 @@ For specific details on how to export weights see [HERE](./docs/exporting_weight For specific details on how to run: - 2D object detection demos, details on FP16, INT8 and batching see [HERE](./docs/demo.md). - segmentation demos see [HERE](./docs/README_seg.md). +- monocular depth estimation see [HERE](./docs/README_depth.md). - 2D/3D object detection and tracking demos see [HERE](./docs/README_2d3dtracking.md). - mAP demo to evaluate 2D object detectors see [HERE](./docs/mAP_demo.md). ![demo](https://user-images.githubusercontent.com/11562617/72547657-540e7800-388d-11ea-83c6-49dfea2a0607.gif) -## tkDNN on Windows 10 (experimental) +## tkDNN on Windows 10 or Windows 11 -For specific details on how to run tkDNN on Windows 10 see [HERE](./docs/windows.md). +For specific details on how to run tkDNN on Windows 10/11 see [HERE](./docs/windows.md). ## Existing tests and supported networks @@ -182,6 +187,8 @@ For specific details on how to run tkDNN on Windows 10 see [HERE](./docs/windows | shelfnet_berkeley | ShelfNet18_realtime11 | [DeepDrive](https://bdd-data.berkeley.edu/) | 20 | 1024x1024 | [weights](https://cloud.hipert.unimore.it/s/m92e7QdD9gYMF7f/download) | | dla34_cnet3d | Centernet3D (DLA34 backend)4 | [KITTI 2017](http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d) | 1 | 512x512 | [weights](https://cloud.hipert.unimore.it/s/2MDyWGzQsTKMjmR/download) | | dla34_ctrack | CenterTrack (DLA34 backend)12 | [NuScenes 3D](https://www.nuscenes.org/) | 7 | 512x512 | [weights](https://cloud.hipert.unimore.it/s/rjNfgGL9FtAXLHp/download) | +| monodepth2 | Monodepth2 13 | [KITTI DEPTH](http://www.cvlibs.net/datasets/kitti/raw_data.php) | - | 640x192 | [weights-mono](https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download) | +| monodepth2 | Monodepth2 13 | [KITTI DEPTH](http://www.cvlibs.net/datasets/kitti/raw_data.php) | - | 640x192 | [weights-stereo](https://cloud.hipert.unimore.it/s/XmwbWNXDfqyQ4EL/download) | ## References @@ -198,3 +205,11 @@ For specific details on how to run tkDNN on Windows 10 see [HERE](./docs/windows 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. +13. Godard, Clément, et al. "Digging into self-supervised monocular depth estimation." Proceedings of the IEEE/CVF International Conference on Computer Vision. 2019. + +## Contributors +The main contibutors, in chronological order, are: +- [Francesco Gatti](https://github.com/ceccocats), francesco.gatti@hipert.it +- [Micaela Verucchi](https://github.com/mive93), micaela.verucchi@unimore.it +- [Davide Sapienza](https://github.com/sapienzadavide), davide.sapienza@unimore.it +- [Harshvardhan Chandirasekar](https://github.com/perseusdg), f20180523@goa.bits-pilani.ac.in diff --git a/cmake/getCudaArch.cu b/cmake/getCudaArch.cu new file mode 100644 index 0000000..1d66199 --- /dev/null +++ b/cmake/getCudaArch.cu @@ -0,0 +1,20 @@ +#include + +int main(int argc, char **argv){ + cudaDeviceProp dP; + float min_cc = 5.0; + + int rc = cudaGetDeviceProperties(&dP, 0); + if(rc != cudaSuccess) { + cudaError_t error = cudaGetLastError(); + printf("CUDA error: %s", cudaGetErrorString(error)); + return rc; /* Failure */ + } + if((dP.major+(dP.minor/10)) < min_cc) { + printf("Min Compute Capability of %2.1f required: %d.%d found\n Not Building CUDA Code", min_cc, dP.major, dP.minor); + return 1; /* Failure */ + } else { + printf("-arch=sm_%d%d", dP.major, dP.minor); + return 0; /* Success */ + } +} \ No newline at end of file diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 5445d86..c857086 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -37,14 +37,18 @@ int main(int argc, char *argv[]) { if(!fileExist(net.c_str())) FatalError("The given network does not exist. Create the rt first."); - #ifdef __linux__ + #ifdef __linux__ std::string input = YAMLgetConf(conf, "input", "../demo/yolo_test.mp4"); + std::string cfgPath = YAMLgetConf(conf,"cfg_input", "../tests/darknet/cfg/yolo4tiny.cfg"); + std::string namePath = YAMLgetConf(conf,"name_input","../tests/darknet/names/coco.names"); #elif _WIN32 - std::string input = YAMLgetConf(conf, "win_input", "..\\..\\..\\demo\\yolo_test.mp4"); + std::string input = YAMLgetConf(conf, "win_input", "..\\..\\..\\demo\\yolo_test.mp4"); + std::string cfgPath = YAMLgetConf(conf,"cfg_win_input","..\\..\\..\\tests\\darknet\\cfg\\yolo4tiny.cfg"); + std::string namePath = YAMLgetConf(conf,"name_win_input","..\\..\\..\\tests\\darknet\\names\\coco.names"); #endif - if(!fileExist(input.c_str())) + if(!fileExist(input.c_str())) FatalError("The given input video does not exist."); - + char ntype = YAMLgetConf(conf, "ntype", 'y'); int n_classes = YAMLgetConf(conf, "n_classes", 80); int n_batch = YAMLgetConf(conf, "n_batch", 1); @@ -66,7 +70,7 @@ int main(int argc, char *argv[]) { // create detection network tk::dnn::Yolo3Detection yolo; tk::dnn::CenternetDetection cnet; - tk::dnn::MobilenetDetection mbnet; + tk::dnn::MobilenetDetection mbnet; tk::dnn::DetectionNN *detNN; @@ -86,7 +90,12 @@ int main(int argc, char *argv[]) { FatalError("Network type not allowed (3rd parameter)\n"); } - detNN->init(net, n_classes, n_batch, conf_thresh); + if(ntype == 'c' || ntype == 'm'){ + cfgPath = ""; + namePath = ""; + } + + detNN->init(net,cfgPath,namePath,n_classes,n_batch,conf_thresh); // open video stream cv::VideoCapture cap(input); @@ -146,10 +155,10 @@ int main(int argc, char *argv[]) { double mean = 0; std::cout<stats.begin(), detNN->stats.end())/n_batch<<" ms\n"; - std::cout<<"Max: "<<*std::max_element(detNN->stats.begin(), detNN->stats.end())/n_batch<<" ms\n"; + std::cout<<"Min: "<<*std::min_element(detNN->stats.begin(), detNN->stats.end())<<" ms\n"; + std::cout<<"Max: "<<*std::max_element(detNN->stats.begin(), detNN->stats.end())<<" ms\n"; for(int i=0; istats.size(); i++) mean += detNN->stats[i]; mean /= detNN->stats.size(); - std::cout<<"Avg: "< +#include +#include /* srand, rand */ +//#include +#include + +#include "tkDNN/DepthNN.h" + +bool gRun; + +void sig_handler(int signo) { + std::cout<<"request gateway stop\n"; + gRun = false; +} + +int main(int argc, char *argv[]) { + + signal(SIGINT, sig_handler); + + std::string net = "monodepth2_fp32.rt"; + if(argc > 1) + net = argv[1]; + #ifdef __linux__ + std::string input = "../demo/yolo_test.mp4"; + #elif _WIN32 + std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; + #endif + if(argc > 2) + input = argv[2]; + bool show = true; + if(argc > 3) + show = atoi(argv[3]); + bool save = true; + if(argc > 4) + save = atoi(argv[4]); + + std::cout <<"Net settings - net: "<< net + <<"\n"; + std::cout <<"Demo settings - input: "<< input + <<", show: "<< show + <<", save: "<< save<<"\n\n"; + + tk::dnn::DepthNN depthNN; + + // create depth network + int n_batch = 1; + depthNN.init(net, n_batch); + + // open video stream + cv::VideoCapture cap(input); + if(!cap.isOpened()) + gRun = false; + else + std::cout<<"camera started\n"; + + cv::VideoWriter resultVideo; + if(save) { + int w = depthNN.output_w; + int h = depthNN.output_h; + resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','P','4','V'), 30, cv::Size(w, h)); + } + + if(show) + cv::namedWindow("depth", cv::WINDOW_NORMAL); + + cv::Mat frame; + std::vector batch_frame; + std::vector batch_dnn_input; + + // start detection loop + gRun = true; + while(gRun) { + batch_dnn_input.clear(); + batch_frame.clear(); + + //read frame + cap >> frame; + if(!frame.data) + break; + batch_frame.push_back(frame); + batch_dnn_input.push_back(frame.clone()); + + //inference + depthNN.update(batch_dnn_input, 1); + if(show){ + cv::imshow("depth", depthNN.depthMats[0]); + cv::waitKey(1); + + } + + if(save) + resultVideo << depthNN.depthMats[0]; + } + + std::cout<<"detection end\n"; + + double mean = 0; + std::cout< 1) net = argv[1]; if(argc > 2) - ntype = argv[2][0]; + ntype = argv[2][0]; if(argc > 3) - labels_path = argv[3]; + cfg_path = argv[3]; if(argc > 4) - config_filename = argv[4]; + name_path = argv[4]; if(argc > 5) - n_batches = atoi(argv[5]); + labels_path = argv[5]; if(argc > 6) - confidence_thresh = atof(argv[6]); + config_filename = argv[6]; + if(argc > 7) + n_batches = atoi(argv[7]); + if(argc > 8) + confidence_thresh = atof(argv[8]); std::cout<<"conf t: "<init(net, n_classes, 1, conf_thresh); + detNN->init(net,cfg_path,name_path,n_classes, 1, conf_thresh); //read images std::ifstream all_labels(labels_path); diff --git a/demo/demo/seg_demo.cpp b/demo/demo/seg_demo.cpp index 2b491d8..f22e5c2 100644 --- a/demo/demo/seg_demo.cpp +++ b/demo/demo/seg_demo.cpp @@ -1,7 +1,9 @@ #include #include #include /* srand, rand */ +#ifdef __linux__ #include +#endif #include #include "SegmentationNN.h" diff --git a/demo/demoConfig.yaml b/demo/demoConfig.yaml index 6cdaff7..194d466 100644 --- a/demo/demoConfig.yaml +++ b/demo/demoConfig.yaml @@ -2,6 +2,14 @@ input : "../demo/yolo_test.mp4" win_input : "..\\..\\..\\demo\\yolo_test.mp4" +#cfg input +cfg_input : "../tests/darknet/cfg/yolo4tiny.cfg" +cfg_win_input : "..\\..\\..\\tests\\darknet\\cfg\\yolo4tiny.cfg" + +#name input +name_input : "../tests/darknet/names/coco.names" +name_win_input : "..\\..\\..\\tests\\darknet\\names\\coco.names" + # network config net : "yolo4tiny_fp32.rt" ntype : 'y' @@ -11,4 +19,4 @@ conf_thresh : 0.3 # demo config show : true -save : true \ No newline at end of file +save : false diff --git a/docker/Dockerfile.base b/docker/Dockerfile.base index e61b0d3..1e235d1 100644 --- a/docker/Dockerfile.base +++ b/docker/Dockerfile.base @@ -1,57 +1,140 @@ -FROM nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04 -LABEL maintainer "Francesco Gatti" +FROM nvidia/cudagl:11.3.1-devel-ubuntu20.04 -ADD nv-tensorrt-repo-ubuntu1804-cuda10.2-trt7.0.0.11-ga-20191216_1-1_amd64.deb /tmp/trt.deb -RUN apt-get update && dpkg -i /tmp/trt.deb && rm /tmp/trt.deb && apt-get update -RUN apt install -y libnvinfer7=7.0.0-1+cuda10.2 libnvinfer-dev=7.0.0-1+cuda10.2 -RUN DEBIAN_FRONTEND=noninteractive apt install -y git wget libeigen3-dev libyaml-cpp-dev -RUN cd /tmp && \ - wget https://github.com/Kitware/CMake/releases/download/v3.17.3/cmake-3.17.3-Linux-x86_64.sh && \ - chmod +x cmake-3.17.3-Linux-x86_64.sh && \ - ./cmake-3.17.3-Linux-x86_64.sh --prefix=/usr/local --exclude-subdir --skip-license && \ - rm ./cmake-3.17.3-Linux-x86_64.sh +LABEL maintainer "TKDNN AUTHORS" +LABEL Description="tkDNN+cudagl" +LABEL com.tkdnn.nvidia.version="11.3.1" -RUN echo "INSTALL OPENCV" -RUN apt-get install -y build-essential \ - unzip \ - pkg-config \ - libjpeg-dev \ - libpng-dev \ - libtiff-dev \ - libavcodec-dev \ - libavformat-dev \ - libswscale-dev \ - libv4l-dev \ - libxvidcore-dev \ - libx264-dev \ - libgtk-3-dev \ - libatlas-base-dev \ - gfortran \ - libgstreamer1.0-dev \ - libgstreamer-plugins-base1.0-dev \ - libdc1394-22-dev \ - libavresample-dev -RUN cd && wget https://github.com/opencv/opencv/archive/4.3.0.tar.gz && tar -xf 4.3.0.tar.gz && rm *.tar.gz -RUN cd && wget https://github.com/opencv/opencv_contrib/archive/4.3.0.tar.gz && tar -xf 4.3.0.tar.gz && rm *.tar.gz -RUN cd && \ - cd opencv-4.3.0 && mkdir build && cd build && \ +ENV DEBIAN_FRONTEND noninteractive +ENV CC gcc +ENV CXX g++ + +RUN apt-get update && apt-get install -y \ +libblkid-dev && apt-get clean && rm -rf /var/lib/apt/lists/* + +RUN apt-get update && apt-get install -y \ +libcudnn8-dev=8.2.1.32-1+cuda11.3 \ +libcudnn8=8.2.1.32-1+cuda11.3 \ +libnvinfer-dev=8.0.3-1+cuda11.3 \ +libnvinfer8=8.0.3-1+cuda11.3 && apt-get clean && rm -rf /var/lib/apt/lists/* + +RUN apt-get update && apt-get install -y --no-install-recommends \ +libblkid-dev \ +locales \ +lsb-release \ +mesa-utils \ +git \ +nano \ +terminator \ +wget \ +curl \ +libssl-dev \ +htop \ +dbus-x11 \ +libqt5opengl5-dev \ +libgtk-3-dev \ +libvtk7-dev \ +libv4l-dev \ +tar \ +libgoogle-glog-dev \ +libgflags-dev \ +gfortran-9 \ +libtbb-dev \ +libgstreamer1.0-dev \ +libgstreamer-plugins-base1.0-dev \ +libdc1394-22-dev \ +libavresample-dev \ +libatlas-cpp-0.6-dev \ +python3-dev \ +gdb \ +python3-pip \ +unzip libtbb-dev && \ +apt-get clean && rm -rf /var/lib/apt/lists/* + +RUN apt-get update && apt-get install -y --no-install-recommends \ +software-properties-common && apt-get clean && rm -rf /var/lib/apt/lists/* + +RUN apt-add-repository universe +RUN apt-get update && apt-get install -y python3-pip python3 openssh-server ssh pyqt5-dev sip-dev && apt-get clean && rm -rf /var/lib/apt/lists/* +RUN pip3 install --upgrade pip +RUN pip3 install --upgrade virtualenv +RUN pip3 install --upgrade paramiko +RUN pip3 install --ignore-installed --upgrade numpy protobuf + + +RUN cd ~ && mkdir build +RUN cd ~/build && wget https://github.com/Kitware/CMake/releases/download/v3.21.4/cmake-3.21.4.tar.gz && \ +tar -xvf cmake-3.21.4.tar.gz && cd cmake-3.21.4 && ./configure --prefix=/usr/local --qt-gui --parallel=12 && \ +make -j8 && make install + +RUN apt-get update && apt-get install -y automake autoconf pkg-config libevent-dev libncurses5-dev bison && \ +apt-get clean && rm -rf /var/lib/apt/lists/ + +RUN git clone https://github.com/tmux/tmux.git && \ +cd tmux && git checkout tags/3.2 && ls -la && sh autogen.sh && ./configure && make -j8 && make install + +RUN apt-get update && apt-get install -y zsh && apt-get clean && rm -rf /var/lib/apt/lists/* +RUN wget https://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | zsh || true +RUN chsh -s /usr/bin/zsh root +RUN git clone https://github.com/sindresorhus/pure /root/.oh-my-zsh/custom/pure +RUN ln -s /root/.oh-my-zsh/custom/pure/pure.zsh-theme /root/.oh-my-zsh/custom/ +RUN ln -s /root/.oh-my-zsh/custom/pure/async.zsh /root/.oh-my-zsh/custom/ +RUN sed -i -e 's/robbyrussell/refined/g' /root/.zshrc +RUN sed -i '/plugins=(/c\plugins=(git git-flow adb pyenv tmux)' /root/.zshrc + +RUN mkdir -p /root/.config/terminator/ +COPY assets/terminator_config /root/.config/terminator/config + +RUN echo "/usr/local/nvidia/lib" >> /etc/ld.so.conf.d/nvidia.conf && \ + echo "/usr/local/nvidia/lib64" >> /etc/ld.so.conf.d/nvidia.conf && \ + echo "/usr/local/cuda/lib64" >> /etc/ld.so.conf.d/nvidia.conf + + +ENV PATH /usr/local/nvidia/bin:/usr/local/cuda/bin:${PATH} +ENV LD_LIBRARY_PATH /usr/local/nvidia/lib:/usr/local/nvidia/lib64:/usr/local/cuda/lib64:/usr/lib:/usr/lib/x86_64-linux-gnu:/usr/local/lib:${LD_LIBRARY_PATH} +ENV NVIDIA_VISIBLE_DEVICES all +ENV NVIDIA_DRIVER_CAPABILITIES compute,utility,graphics + + + +RUN cd ~/build && wget https://github.com/opencv/opencv/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm 4.5.4.tar.gz +RUN cd ~/build && wget https://github.com/opencv/opencv_contrib/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm 4.5.4.tar.gz +RUN cd ~/build && \ + cd opencv-4.5.4 && mkdir build && cd build && \ cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_EXAMPLES=OFF \ -D INSTALL_C_EXAMPLES=OFF \ - -D OPENCV_EXTRA_MODULES_PATH='~/opencv_contrib-4.3.0/modules' \ + -D OPENCV_EXTRA_MODULES_PATH='~/build/opencv_contrib-4.5.4/modules' \ -D BUILD_EXAMPLES=OFF \ + -D BUILD_TESTS=OFF \ + -D BUILD_PERF_TESTS=OFF \ + -D BUILD_DOCS=OFF \ -D WITH_CUDA=ON \ + -D WITH_OPENGL=ON \ + -D WITH_NVCUVID=ON \ -D CUDA_ARCH_BIN=7.2 \ - -D CUDA_ARCH_PTX="" \ + -D CUDA_ARCH_PTX=7.2 \ -D ENABLE_FAST_MATH=ON \ -D CUDA_FAST_MATH=ON \ -D WITH_CUBLAS=ON \ + -D WITH_CUDNN=ON \ + -D WITH_OPENMP=ON \ + -D WITH_NONFREE=ON \ -D WITH_LIBV4L=ON \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ -D WITH_TBB=ON \ - ../ && make -j12 && make install -RUN apt clean + ../ && make -j12 && make install && ldconfig +RUN cd ~ && rm -rf build +RUN cd ~ && mkdir Development && cd Development && \ +git clone https://github.com/ceccocats/tkDNN.git && cd tkDNN && \ +mkdir build && cd build && \ +cmake -DCMAKE_BUILD_TYPE=Release .. && \ +make -j6 + +RUN apt-get clean && rm -rf /var/lib/apt/lists/* +COPY assets/entrypoint_setup.sh / +ENTRYPOINT ["/entrypoint_setup.sh"] +CMD ["terminator"] \ No newline at end of file diff --git a/docker/README.md b/docker/README.md index aec202a..15f3987 100644 --- a/docker/README.md +++ b/docker/README.md @@ -9,13 +9,10 @@ docker build -t tkdnn:build -f Dockerfile . # make nvidia docker working # follow this guide: https://github.com/NVIDIA/nvidia-docker -# dowload tensorrt -# from: https://developer.nvidia.com/compute/machine-learning/tensorrt/secure/7.0/7.0.0.11/local_repo/nv-tensorrt-repo-ubuntu1804-cuda10.2-trt7.0.0.11-ga-20191216_1-1_amd64.deb - # build image docker build -t ceccocats/tkdnn:latest -f Dockerfile.base . # run image -docker run -ti --gpus all --rm ceccocats/tkdnn:latest bash +./docker_launch.sh ``` diff --git a/docker/assets/entrypoint_setup.sh b/docker/assets/entrypoint_setup.sh new file mode 100755 index 0000000..348a4f5 --- /dev/null +++ b/docker/assets/entrypoint_setup.sh @@ -0,0 +1,123 @@ +#! /bin/bash + +CMD= + +# Functions +# TOOD: Check if we can use: getent passwd $USER to extract all variables +# TODO: Check for valid inputs, cause now it will go through even with bad inputs +check_envs () { + DOCKER_CUSTOM_USER_OK=true; + if [ -z ${DOCKER_USER_NAME+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + fi + + if [ -z ${DOCKER_USER_ID+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + else + if ! [ -z "${DOCKER_USER_ID##[0-9]*}" ]; then + echo -e "\033[1;33mWarning: User-ID should be a number. Falling back to defaults.\033[0m" + DOCKER_CUSTOM_USER_OK=false; + return; + fi + fi + + if [ -z ${DOCKER_USER_GROUP_NAME+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + fi + + if [ -z ${DOCKER_USER_GROUP_ID+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + else + if ! [ -z "${DOCKER_USER_GROUP_ID##[0-9]*}" ]; then + echo -e "\033[1;33mWarning: Group-ID should be a number. Falling back to defaults.\033[0m" + DOCKER_CUSTOM_USER_OK=false; + return; + fi + fi +} + +setup_env_user () { + USER=$1 + USER_ID=$2 + GROUP=$3 + GROUP_ID=$4 + + ## Create user + useradd -m $USER + + ## Copy zsh/sh configs + cp /root/.profile /home/$USER/ + cp /root/.bashrc /home/$USER/ + cp /root/.zshrc /home/$USER/ + ## Copy terminator configs + mkdir -p /home/$USER/.config/terminator + cp /root/.config/terminator/config /home/$USER/.config/terminator/config + cp /root/.config/terminator/background.png /home/$USER/.config/terminator/background.png + cp -rf /root/.oh-my-zsh /home/$USER/ + cp -rf /root/tkDNN /home/$USER/ + rm -rf /home/$USER/.oh-my-zsh/custom/pure.zsh-theme /home/$USER/.oh-my-zsh/custom/async.zsh + ln -s /home/$USER/.oh-my-zsh/custom/pure/pure.zsh-theme /home/$USER/.oh-my-zsh/custom/ + ln -s /home/$USER/.oh-my-zsh/custom/pure/async.zsh /home/$USER/.oh-my-zsh/custom/ + sed -i -e 's@ZSH=\"/root@ZSH=\"/home/$USER@g' /home/$USER/.zshrc + # Copy SSH keys & fix owner + if [ -d "/root/.ssh" ]; then + cp -rf /root/.ssh /home/$USER/ + chown -R $USER:$GROUP /home/$USER/.ssh + fi + + ## Fix owner + chown $USER:$GROUP /home/$USER + chown -R $USER:$GROUP /home/$USER/.config + chown $USER:$GROUP /home/$USER/.profile + chown $USER:$GROUP /home/$USER/.bashrc + chown $USER:$GROUP /home/$USER/.zshrc + chown -R $USER:$GROUP /home/$USER/.oh-my-zsh + chown -R $USER:$GROUP /home/$USER/tkDNN + + ## This a trick to keep the evnironmental variables of root which is important! + echo "if ! [ \"$DOCKER_USER_NAME\" = \"$(id -un)\" ]; then" >> /root/.bashrc + echo " cd /home/$DOCKER_USER_NAME" >> /root/.bashrc + echo " su $DOCKER_USER_NAME" >> /root/.bashrc + echo "fi" >> /root/.bashrc + + echo "if ! [ \"$DOCKER_USER_NAME\" = \"$(id -un)\" ]; then" >> /root/.zshrc + echo " cd /home/$DOCKER_USER_NAME" >> /root/.zshrc + echo " su $DOCKER_USER_NAME" >> /root/.zshrc + echo "fi" >> /root/.zshrc + + ## Setup Password-file + PASSWDCONTENTS=$(grep -v "^${USER}:" /etc/passwd) + GROUPCONTENTS=$(grep -v -e "^${GROUP}:" -e "^docker:" /etc/group) + + (echo "${PASSWDCONTENTS}" && echo "${USER}:x:$USER_ID:$GROUP_ID::/home/$USER:/bin/bash") > /etc/passwd + (echo "${GROUPCONTENTS}" && echo "${GROUP}:x:${GROUP_ID}:") > /etc/group + (if test -f /etc/sudoers ; then echo "${USER} ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers ; fi) +} + + +# ---Main--- + +# Create new user +## Check Inputs +check_envs + +## Determine user & Setup Environment +if [ $DOCKER_CUSTOM_USER_OK == true ]; then + echo " -->DOCKER_USER Input is set to '$DOCKER_USER_NAME:$DOCKER_USER_ID:$DOCKER_USER_GROUP_NAME:$DOCKER_USER_GROUP_ID'"; + echo -e "\033[0;32mSetting up environment for user=$DOCKER_USER_NAME\033[0m" + setup_env_user $DOCKER_USER_NAME $DOCKER_USER_ID $DOCKER_USER_GROUP_NAME $DOCKER_USER_GROUP_ID +else + echo " -->DOCKER_USER* variables not set. Using 'root'."; + echo -e "\033[0;32mSetting up environment for user=root\033[0m" + DOCKER_USER_NAME="root" +fi + +# Change shell to zsh +chsh -s /usr/bin/zsh $DOCKER_USER_NAME + +# Run CMD from Docker +"$@" \ No newline at end of file diff --git a/docker/assets/terminator_config b/docker/assets/terminator_config new file mode 100644 index 0000000..d65a1b3 --- /dev/null +++ b/docker/assets/terminator_config @@ -0,0 +1,18 @@ +[global_config] + title_transmit_bg_color = "#2e3436" +[keybindings] +[layouts] + [[default]] + [[[child1]]] + parent = window0 + type = Terminal + [[[window0]]] + parent = "" + type = Window +[plugins] +[profiles] + [[default]] + background_color = "#282828" + cursor_color = "#aaaaaa" + foreground_color = "#f3f3f3" + palette = "#000000:#aa0000:#00aa00:#c4a000:#3465a4:#75507b:#06989a:#d3d7cf:#88807c:#f15d22:#73c48f:#ffce51:#48b9c7:#ad7fa8:#34e2e2:#eeeeec" diff --git a/docker/docker_launch.sh b/docker/docker_launch.sh new file mode 100755 index 0000000..24adb53 --- /dev/null +++ b/docker/docker_launch.sh @@ -0,0 +1,9 @@ +xhost local:root +docker run --rm -it --runtime=nvidia --privileged --net=host --cap-add sys_ptrace -d --ipc=host \ +-v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=$DISPLAY \ +-v $HOME/.Xauthority:/home/$(id -un)/.Xauthority -e XAUTHORITY=/home/$(id -un)/.Xauthority \ +-e DOCKER_USER_NAME=$(id -un) \ +-e DOCKER_USER_ID=$(id -u) \ +-e DOCKER_USER_GROUP_NAME=$(id -gn) \ +-e DOCKER_USER_GROUP_ID=$(id -g) \ +-v $HOME/.ssh:/home/$(id -un)/.ssh ceccocats/tkdnn diff --git a/docs/README_depth.md b/docs/README_depth.md new file mode 100644 index 0000000..ac87bb6 --- /dev/null +++ b/docs/README_depth.md @@ -0,0 +1,54 @@ +# Monocular depth estimation with tkDNN + +Currently tkDNN supports only Monodepth2 as monocular depth esitmation network. + + +## Run the demo + +To run the depth estimation demo follow these steps (example with monodepth2): +``` +rm monodepth2_fp32.rt # be sure to delete(or move) old tensorRT files +./test_monodepth2 # run the yolo test (is slow) +./demoDepth monodepth2_fp32.rt ../demo/yolo_test.mp4 +``` +In general the demo program takes the following parameters: +``` +./demoDepth +``` +where +* `````` is the rt file generated by a test +* ```<``` is the path to a video file or a camera input +* `````` if set to 0 the demo will not show the visualization, it will otherwise (default=1) +* `````` if set to 1 the demo will save the video into result.mp4, it won't otherwise (default=1) + +NB) By default it is used FP32 inference + + +![demo](https://user-images.githubusercontent.com/11939259/160845358-0d6ab15d-c5f4-46ae-b9da-bfaf3903389d.gif "Results on yolo_test.mp4") + + + + diff --git a/docs/demo.md b/docs/demo.md index 5971781..bf6b79d 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -26,26 +26,28 @@ rm yolo4_fp32.rt # be sure to delete(or move) old tensorRT files ``` If you get problems in the creation, try to check the error activating the debug of TensorRT in this way: ``` -cmake .. -DDEBUG=True +cmake .. -DCMAKE_BUILD_TYPE=Debug -DDEBUG=True make ``` -Once you have successfully created your rt file, run the demo: +Once you have successfully created your rt file, run the demo: ``` -./demo +./ demo ``` -In general the demo program takes 1 parameter, the `````` that is the path to che configuration file. The parameter is optional and its default value is ```"../demo/demoConfig.yaml"```. +In general the demo program takes 1 parameter, the `````` that is the path to che configuration file. The parameter is optional and its default value is ```"../demo/demoConfig.yaml"```. The config file is a yaml file with the following attributes: -* ```net``` is the rt file generated by a test -* ```input``` is the path to a video file or a camera input (on Linux) -* ```win_input``` is the path to a video file or a camera input (on Windows) -* ```ntype``` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) -* ```n_classes``` is the number of classes the network is trained on -* ```n_batch``` 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). -* ```conf_thresh``` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. -* ```show``` if set to 0 the demo will not show the visualization (if n-batches ==1) -* ```save``` if set to 1 the demo will save the video of the demo into result.mp4 (if n-batches ==1) +* ```net``` is the rt file generated by a test +* ```input``` is the path to a video file or a camera input (on Linux) +* ```win_input``` is the path to a video file or a camera input (on Windows) +* ```ntype``` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) +* ```n_classes``` is the number of classes the network is trained on +* ```n_batch``` 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). +* ```conf_thresh``` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. +* ```show``` if set to 0 the demo will not show the visualization (if n-batches ==1) +* ```save``` if set to 1 the demo will save the video of the demo into result.mp4 (if n-batches ==1) +* ```cfg_input``` (for linux) \ ```cfg_win_input``` (for windows) is the location of the cfg path of the network for mobilenet and centernet networks use ```" "``` +* ```name_input``` (for linux) \ ```name_win_input``` (for windows) is the location of the name path of the network for mobilenet and centernet networks use ```" "``` N.B. By default it is used FP32 inference @@ -58,10 +60,10 @@ N.B. By default it is used FP32 inference To run the demo with FP16 inference follow these steps (example with yolov3): ``` export TKDNN_MODE=FP16 # set the half floating point optimization -rm yolo3_fp16.rt # be sure to delete(or move) old tensorRT files -./test_yolo3 # run the yolo test (is slow) -# set net: yolo3_fp16.rt in the config-file -./demo +rm yolo4_fp16.rt # be sure to delete(or move) old tensorRT files +./test_yolo4 # run the yolo test (is slow) +#set net: yolo4_fp16.rt in the config file +./demo ``` N.B. Using FP16 inference will lead to some errors in the results (first or second decimal). @@ -84,10 +86,10 @@ Then a complete example using yolo3 and COCO dataset would be: export TKDNN_MODE=INT8 export TKDNN_CALIB_LABEL_PATH=../demo/COCO_val2017/all_labels.txt export TKDNN_CALIB_IMG_PATH=../demo/COCO_val2017/all_images.txt -rm yolo3_int8.rt # be sure to delete(or move) old tensorRT files -./test_yolo3 # run the yolo test (is slow) -# set net: yolo3_int8.rt in the config-file -./demo +rm yolo4_int8.rt # be sure to delete(or move) old tensorRT files +./test_yolo4 # run the yolo test (is slow) +#set net: yolo4_int8.rt in the config file +./demo ``` N.B. diff --git a/docs/exporting_weights.md b/docs/exporting_weights.md index 811431d..b4cb366 100644 --- a/docs/exporting_weights.md +++ b/docs/exporting_weights.md @@ -86,6 +86,18 @@ mkdir layer debug python export.py ``` +### 6)Export weights for monodepth2 +To get the weights needed to run Shelfnet tests use [this](https://github.com/perseusdg/monodepth2) fork of a Pytorch implementation of monodepth2 network. + +``` +git clone https://github.com/perseusdg/monodepth2 +cd monodepth2 +mkdir models # Download the official weights and put depth.pth and encorder.pth inside this new folder +conda env create --file monodepth.yaml +conda activate monodepth2 +python exporter.py # you will find the weights inside the tkDNN_bin folder +``` + ## Darknet Parser tkDNN implement and easy parser for darknet cfg files, a network can be converted with *tk::dnn::darknetParser*: ``` diff --git a/docs/windows.md b/docs/windows.md index 60813c5..fced442 100644 --- a/docs/windows.md +++ b/docs/windows.md @@ -7,17 +7,18 @@ - [Run the demo on Windows](#run-the-demo-on-windows) - [FP16 inference windows](#fp16-inference-windows) - [INT8 inference windows](#int8-inference-windows) + - [Run tkDNN on WSL2 with cuda](#tkdnn-on-cuda-wsl) - [Known issues with tkDNN on Windows](#known-issues-with-tkdnn-on-windows) ### Dependencies-Windows This branch should work on every NVIDIA GPU supported in windows with the following dependencies: -* WINDOWS 10 1803 or HIGHER -* CUDA 10.0 (Recommended CUDA 11.2 ) -* CUDNN 7.6 (Recommended CUDNN 8.1.1 ) -* TENSORRT 6.0.1 (Recommended TENSORRT 7.2.3.4 ) -* OPENCV 3.4 (Recommended OPENCV 4.2.0 ) -* MSVC 16.7 +* WINDOWS 10 1803/WINDOWS 11 or HIGHER +* CUDA 11.2 +* CUDNN 8.1.1 +* TENSORRT 7.2.3 +* OPENCV 4.2 +* MSVC 16.9+ * YAML-CPP * EIGEN3 * 7ZIP (ADD TO PATH) @@ -58,7 +59,7 @@ To run the object detection file create .rt file bu running: Once the rt file has been successfully create,run the demo using the following command: ``` -.\demo.exe yolo4tiny_fp32.rt ..\demo\yolo_test.mp4 y +.\demo.exe yolo4_fp32.rt ..\demo\yolo_test.mp4 y 80 ..\tests\darknet\cfg\yolo4.cfg ..\tests\darknet\names\cococ.names ``` For general info on more demo paramters,check Run the demo section on top To run the test_all_tests.sh on windows,use git bash or msys2 @@ -85,11 +86,17 @@ del /f yolo4tiny_int8.rt # be sure to delete(or move) old tensorRT files ``` +### Run tkDNN on WSL2 with cuda +tkDNN works on wsl2 with cuda,although not all networks (centernet,mobilenet) work properly. +If you encounter issues with running the network as a result of driver not found or cuda launch error,running the following command should solve the issue +```cp /usr/lib/wsl/lib/lib* /usr/lib/x86_64-linux-gnu/ ``` + + + ### Known issues with tkDNN on Windows -Mobilenet and Centernet demos work properly only when built with msvc 16.7 in Release Mode,when built in debug mode for the mentioned networks one might encounter opencv assert errors +In theory all models (centernet,mobilenet,darknet,centertrack,cnet3d and shelfnet) should work on Windows. -All Darknet models work properly with demo using MSVC version(16.7-16.9) +On pascal cards(sm 6x) ,nvidia cuda wsl driver 510.06 don't work well with tkDNN both on windows and cuda wsl , Nvidia drivers >465+ and < 500 are completely supported . -It is recommended to use Nvidia Driver(465+),Cuda unknown errors have been observed when using older drivers on pascal(SM 61) devices. diff --git a/include/tkDNN/CenterTrack.h b/include/tkDNN/CenterTrack.h index 783a44e..aa573fa 100644 --- a/include/tkDNN/CenterTrack.h +++ b/include/tkDNN/CenterTrack.h @@ -13,6 +13,11 @@ #include "TrackingNN.h" +#ifdef _WIN32 +#define _USE_MATH_DEFINES +#include +#endif + #include "kernelsThrust.h" diff --git a/include/tkDNN/CenternetDetection.h b/include/tkDNN/CenternetDetection.h index 3c8cfbb..07c80cd 100644 --- a/include/tkDNN/CenternetDetection.h +++ b/include/tkDNN/CenternetDetection.h @@ -73,7 +73,7 @@ public: CenternetDetection() {}; ~CenternetDetection() {}; - bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); + bool init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); void preprocess(cv::Mat &frame, const int bi=0); void postprocess(const int bi=0,const bool mAP=false); }; diff --git a/include/tkDNN/CenternetDetection3D.h b/include/tkDNN/CenternetDetection3D.h index f9c918f..9f2b214 100644 --- a/include/tkDNN/CenternetDetection3D.h +++ b/include/tkDNN/CenternetDetection3D.h @@ -9,6 +9,11 @@ #include // std::iota #include // std::sort +#ifdef _WIN32 +#define _USE_MATH_DEFINES +#include +#endif + #include "DetectionNN3D.h" #include "kernelsThrust.h" diff --git a/include/tkDNN/DarknetParser.h b/include/tkDNN/DarknetParser.h index 089c4d6..c6d2472 100644 --- a/include/tkDNN/DarknetParser.h +++ b/include/tkDNN/DarknetParser.h @@ -47,5 +47,8 @@ namespace tk { namespace dnn { std::vector &netLayers, const std::vector& names); std::vector darknetReadNames(const std::string& names_file); tk::dnn::Network* darknetParser(const std::string& cfg_file, const std::string& wgs_path, const std::string& names_file); + void loadYoloInfo(const std::string &cfg_file,int lineNo,std::vector &mask,std::vector &anchors,int &num,int &classes,float &nms_thresh,int &nms_kind,int &coords); + void loadYoloInitInfo(int &channels,int &width,int &height,const std::string &cfg_file); + std::vector noYolosLine(const std::string &cfg_file); }} diff --git a/include/tkDNN/DepthNN.h b/include/tkDNN/DepthNN.h new file mode 100644 index 0000000..4d34239 --- /dev/null +++ b/include/tkDNN/DepthNN.h @@ -0,0 +1,180 @@ +#ifndef DEPTHNN_H +#define DEPTHNN_H + +#include +#include +#include +#ifdef __linux__ +#include +#endif + +#include + +#include +#include +#include + +#include "tkDNN/utils.h" +#include "tkDNN/tkdnn.h" + +#include "NetworkViz.h" + + +namespace tk { namespace dnn { + +class DepthNN { + + public: + tk::dnn::NetworkRT *netRT = nullptr; + dnnType *input_h; + dnnType *input_d; + float* depth_h; + + int output_w; + int output_h; + + int nBatches = 1; + + cv::Mat bgr[3]; + cv::Mat imagePreproc; + + std::vector stats; /*keeps track of inference times (ms)*/ + std::vector> depths; + std::vector depthMats; + + DepthNN() {}; + ~DepthNN(){}; + + /** + * Method used to initialize the class, allocate memory and compute + * needed data. + * + * @param tensor_path path to the rt file of the NN. + * @param n_batches maximum number of batches to use in inference + * @return true if everything is correct, false otherwise. + */ + void init(const std::string& tensor_path, const int n_batches=1){ + //create net + + std::cout<<(tensor_path).c_str()<<"\n"; + nBatches = n_batches; + netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str()); + + //allocate memory for NN input + checkCuda(cudaMallocHost(&input_h, sizeof(dnnType) * netRT->input_dim.tot() * nBatches)); + checkCuda(cudaMalloc(&input_d, sizeof(dnnType) * netRT->input_dim.tot() * nBatches)); + + //allocate memory for NN output + depthMats.resize(nBatches); + depths.resize(nBatches); + for(int i=0; i< depths.size();++i) + depths[i].resize(netRT->buffersDIM[1].tot()); + + depth_h = (float *)malloc(netRT->buffersDIM[1].tot() * sizeof(float)); + + output_h = netRT->buffersDIM[1].h; + output_w = netRT->buffersDIM[1].w; + + } + + + /** + * This method preprocess the image, before feeding it to the NN. + * + * @param frame original frame to adapt for inference. + * @param bi batch index + */ + void preprocess(cv::Mat &frame, const int bi=0) { + //resize image, remove mean, divide by std + cv::Mat frame_nomean; + resize(frame, frame, cv::Size(netRT->input_dim.w, netRT->input_dim.h)); + frame.convertTo(frame_nomean, CV_32FC3); + frame_nomean.convertTo(imagePreproc, CV_32FC3, 1 / 255.0, 0); + + //copy image into tensor and copy it into GPU + cv::split(imagePreproc, bgr); + for (int i = 0; i < netRT->input_dim.c; i++){ + int idx = i * imagePreproc.rows * imagePreproc.cols; + int ch = netRT->input_dim.c-1 -i; + memcpy((void *)&input_h[idx + netRT->input_dim.tot()*bi], (void *)bgr[ch].data, imagePreproc.rows * imagePreproc.cols * sizeof(dnnType)); + } + checkCuda(cudaMemcpyAsync(input_d+ netRT->input_dim.tot()*bi, input_h + netRT->input_dim.tot()*bi, netRT->input_dim.tot() * sizeof(dnnType), cudaMemcpyHostToDevice, netRT->stream)); + } + + /** + * This method postprocess the output of the NN to obtain the correct + * boundig boxes. + * + * @param bi batch index + * @param mAP set to true only if all the probabilities for a bounding + * box are needed, as in some cases for the mAP calculation + */ + void postprocess(const int bi=0) { + + dnnType *rt_out[1]; + rt_out[0] = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[1].tot()*bi; + checkCuda(cudaMemcpy(depth_h, rt_out[0], netRT->buffersDIM[1].tot()* sizeof(float), cudaMemcpyDeviceToHost)); + memcpy(&depths[bi][0], &depth_h[0], netRT->buffersDIM[1].tot()* sizeof(float)); + + // cv::Mat d(netRT->buffersDIM[1].h, netRT->buffersDIM[1].w, CV_8UC1, depth_h); + // depthMats[bi] = d.clone(); + + cv::Mat depth_mat = vizData2Mat(rt_out[0], netRT->buffersDIM[1], netRT->buffersDIM[1].h, netRT->buffersDIM[1].w); + // cv::Mat depth_mat = vizData2Mat((dnnType *)netRT->buffersRT[0], netRT->buffersDIM[0], netRT->buffersDIM[0].h, netRT->buffersDIM[0].w); + depthMats[bi] = depth_mat.clone(); + + } + + /** + * This method performs the inference of the NN. + * + * @param frames frames to build the embedding from. + * @param cur_batches number of batches to use in inference + */ + void update(std::vector& frames, const int cur_batches=1){ + if(cur_batches > nBatches) + FatalError("A batch size greater than nBatches cannot be used"); + + if(TKDNN_VERBOSE) printCenteredTitle(" TENSORRT feature extraction ", '=', 30); + { + TKDNN_TSTART + for(int bi=0; biinput_dim; + dim.n = cur_batches; + { + if(TKDNN_VERBOSE) dim.print(); + TKDNN_TSTART + netRT->infer(dim, input_d); + TKDNN_TSTOP + if(TKDNN_VERBOSE) dim.print(); + stats.push_back(t_ns); + } + + { + TKDNN_TSTART + for(int bi=0; bi& mListIn); @@ -55,7 +55,7 @@ private: int mFileBatchPos{ 0 }; int mImageSize{ 0 }; - nvinfer1::DimsNCHW mDims; + nvinfer1::Dims4 mDims; std::vector mBatch; std::vector mLabels; std::vector mFileBatch; diff --git a/include/tkDNN/Int8Calibrator.h b/include/tkDNN/Int8Calibrator.h index 4a0ea47..c7a7d97 100644 --- a/include/tkDNN/Int8Calibrator.h +++ b/include/tkDNN/Int8Calibrator.h @@ -30,10 +30,10 @@ public: Int8EntropyCalibrator(BatchStream& stream, int firstBatch, const std::string& calibTableFilePath, const std::string& inputBlobName, bool readCache = true); virtual ~Int8EntropyCalibrator() { checkCuda(cudaFree(mDeviceInput)); } - int getBatchSize() const override { return mStream.getBatchSize(); } - bool getBatch(void* bindings[], const char* names[], int nbBindings) override; - const void* readCalibrationCache(size_t& length) override; - void writeCalibrationCache(const void* cache, size_t length) override; + int getBatchSize() const NOEXCEPT override { return mStream.getBatchSize(); } + bool getBatch(void* bindings[], const char* names[], int nbBindings) NOEXCEPT override; + const void* readCalibrationCache(size_t& length) NOEXCEPT override; + void writeCalibrationCache(const void* cache, size_t length) NOEXCEPT override; private: BatchStream mStream; diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index d1234a5..daa27e5 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -31,7 +31,8 @@ enum layerType_t { LAYER_SHORTCUT, LAYER_UPSAMPLE, LAYER_REGION, - LAYER_YOLO + LAYER_YOLO, + LAYER_PADDING, }; #define TKDNN_BN_MIN_EPSILON 1e-5 @@ -56,8 +57,8 @@ public: int id = 0; bool final; //if the layer is the final one - uint n_params = 0; - uint feature_map_size = 0; + unsigned int n_params = 0; + unsigned int feature_map_size = 0; long unsigned MACC = 0; @@ -87,6 +88,7 @@ public: case LAYER_UPSAMPLE: return "Upsample"; case LAYER_REGION: return "Region"; case LAYER_YOLO: return "Yolo"; + case LAYER_PADDING: return "Padding"; default: return "unknown"; } } @@ -423,6 +425,8 @@ public: virtual layerType_t getLayerType() { return LAYER_FLATTEN; }; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + + int c, h, w, rows, cols; }; /** @@ -436,6 +440,7 @@ public: virtual layerType_t getLayerType() { return LAYER_RESHAPE; }; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int n,c,h,w; }; @@ -470,7 +475,6 @@ public: virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); -protected: dnnType mul, add; dnnType *add_vector; }; @@ -497,6 +501,7 @@ public: int winH, winW; int strideH, strideW; int paddingH, paddingW; + int padding; bool size; tkdnnPoolingMode_t pool_mode; @@ -516,9 +521,35 @@ protected: bool poolOn3d; }; +/** + * Padding Layers + * tkDNN supports reflection,constant and zero padding + */ + +typedef enum { + PADDING_MODE_CONSTANT = 0, + PADDING_MODE_ZERO = 1, + PADDING_MODE_REFLECTION = 2 +} tkdnnPaddingMode_t; + +class Padding : public Layer { +public: + Padding(Network *net,int32_t pad_h,int32_t pad_w,tkdnnPaddingMode_t padding_mode,float constant = 0.0); + virtual ~Padding(); + virtual layerType_t getLayerType(){return LAYER_PADDING ;}; + virtual dnnType* infer(dataDim_t& dim,dnnType* srcData); + int32_t paddingH,paddingW; + tkdnnPaddingMode_t padding_mode; + float constant; + +}; + + + /** Softmax layer */ + class Softmax : public Layer { public: @@ -582,6 +613,8 @@ public: virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int c,h,w; + public: Layer *backLayer; bool mul = false; @@ -602,6 +635,7 @@ public: int stride; bool reverse; + int c,h,w; }; struct box { @@ -685,6 +719,7 @@ public: virtual layerType_t getLayerType() { return LAYER_REGION; }; int classes, coords, num; + int c,h,w; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); }; diff --git a/include/tkDNN/MobilenetDetection.h b/include/tkDNN/MobilenetDetection.h index 9a5fedc..ec35b20 100644 --- a/include/tkDNN/MobilenetDetection.h +++ b/include/tkDNN/MobilenetDetection.h @@ -65,7 +65,7 @@ public: MobilenetDetection() {}; ~MobilenetDetection() {}; - bool init(const std::string& tensor_path, const int n_classes, const int n_batches=1, const float conf_thresh=0.3); + bool init(const std::string& tensor_path, const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches=1, const float conf_thresh=0.3); void preprocess(cv::Mat &frame, const int bi=0); void postprocess(const int bi=0,const bool mAP=false); }; diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 9892a24..a7e67c2 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -7,47 +7,30 @@ #include "Layer.h" #include "NvInfer.h" #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + namespace tk { namespace dnn { -template void writeBUF(char*& buffer, const T& val) -{ - *reinterpret_cast(buffer) = val; - buffer += sizeof(T); -} - -template T readBUF(const char*& buffer) -{ - T val = *reinterpret_cast(buffer); - buffer += sizeof(T); - return val; -} - using namespace nvinfer1; -#include "pluginsRT/ActivationLeakyRT.h" -#include "pluginsRT/ActivationLogisticRT.h" -#include "pluginsRT/ActivationReLUCeilingRT.h" -#include "pluginsRT/ActivationMishRT.h" -#include "pluginsRT/ReorgRT.h" -#include "pluginsRT/RegionRT.h" -#include "pluginsRT/RouteRT.h" -#include "pluginsRT/ShortcutRT.h" -#include "pluginsRT/YoloRT.h" -#include "pluginsRT/UpsampleRT.h" -#include "pluginsRT/ResizeLayerRT.h" -#include "pluginsRT/DeformableConvRT.h" -#include "pluginsRT/FlattenConcatRT.h" -#include "pluginsRT/ReshapeRT.h" -#include "pluginsRT/MaxPoolingFixedSizeRT.h" - -class PluginFactory : IPluginFactory -{ -public: - YoloRT *yolos[16]; - int n_yolos; - - virtual IPlugin* createPlugin(const char* layerName, const void* serialData, size_t serialLength); -}; @@ -69,12 +52,11 @@ public: void* buffersRT[MAX_BUFFERS_RT]; dataDim_t buffersDIM[MAX_BUFFERS_RT]; int buf_input_idx, buf_output_idx; - + bool builderActive = false; dataDim_t input_dim, output_dim; dnnType *output; cudaStream_t stream; - PluginFactory *pluginFactory; NetworkRT(Network *net, const char *name); virtual ~NetworkRT(); @@ -106,18 +88,26 @@ public: nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Pooling *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Softmax *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Route *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Flatten *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Reshape *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Flatten *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Reshape *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Resize *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Reorg *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Region *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Reorg *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Region *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Shortcut *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Yolo *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Yolo *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); + nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input,Padding *l); + nvinfer1::ILayer* convert_layer(nvinfer1::ITensor* input,MulAdd *l); +#if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 bool serialize(const char *filename); +#else + bool serialize(const char *filename,nvinfer1::IHostMemory *ptr); +#endif + bool deserialize(const char *filename); + void destroy(); diff --git a/include/tkDNN/NetworkViz.h b/include/tkDNN/NetworkViz.h index 2cf8009..ffdf361 100644 --- a/include/tkDNN/NetworkViz.h +++ b/include/tkDNN/NetworkViz.h @@ -6,7 +6,7 @@ namespace tk { namespace dnn { cv::Mat vizFloat2colorMap(cv::Mat map, double min=0, double max=0, int classes=19); -cv::Mat vizData2Mat(dnnType *dataInput, tk::dnn::dataDim_t dim, int img_h, int img_w, double min=0, double max=0, int classes=19); +cv::Mat vizData2Mat(dnnType *dataInput, tk::dnn::dataDim_t dim, int img_h, int img_w, double min=0, double max=0, int classes=0); cv::Mat vizLayer2Mat(tk::dnn::Network *net, int layer, int imgdim = 1000); }} diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index b73ffa2..c39323c 100644 --- a/include/tkDNN/SegmentationNN.h +++ b/include/tkDNN/SegmentationNN.h @@ -4,7 +4,9 @@ #include #include #include +#ifdef __linux__ #include +#endif #include #include "utils.h" @@ -181,6 +183,7 @@ class SegmentationNN { checkCuda(cudaMemcpyAsync(mean_d, mean.data(), mean.size() * sizeof(float), cudaMemcpyHostToDevice, netRT->stream)); checkCuda(cudaMemcpyAsync(stddev_d, stddev.data(), stddev.size() * sizeof(float), cudaMemcpyHostToDevice, netRT->stream)); + return true; return true; } diff --git a/include/tkDNN/Yolo3Detection.h b/include/tkDNN/Yolo3Detection.h index 100a720..5a29d9c 100644 --- a/include/tkDNN/Yolo3Detection.h +++ b/include/tkDNN/Yolo3Detection.h @@ -4,9 +4,9 @@ #include "opencv2/opencv.hpp" #include "DetectionNN.h" +#include "DarknetParser.h" -namespace tk { namespace dnn { - +namespace tk { namespace dnn { class Yolo3Detection : public DetectionNN { private: @@ -19,12 +19,13 @@ private: tk::dnn::Yolo* getYoloLayer(int n=0); cv::Mat bgr_h; + std::vector noYolos; public: Yolo3Detection() {}; ~Yolo3Detection() {}; - bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); + bool init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path,const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); void preprocess(cv::Mat &frame, const int bi=0); void postprocess(const int bi=0,const bool mAP=false); }; diff --git a/include/tkDNN/demo_utils.h b/include/tkDNN/demo_utils.h index 06a8970..c39e704 100644 --- a/include/tkDNN/demo_utils.h +++ b/include/tkDNN/demo_utils.h @@ -9,12 +9,13 @@ #ifdef __linux__ #include +#endif + #include #include #include #include -#endif void readCalibrationMatrix(const std::string& path, cv::Mat& calib_mat); diff --git a/include/tkDNN/kernels.h b/include/tkDNN/kernels.h index d809129..4d5474b 100644 --- a/include/tkDNN/kernels.h +++ b/include/tkDNN/kernels.h @@ -48,4 +48,11 @@ void dcnV2CudaForward(cublasStatus_t stat, cublasHandle_t handle, const int dst_dim, cudaStream_t stream = cudaStream_t(0)); void scalAdd(dnnType* dstData, int size, float alpha, float beta, int inc, cudaStream_t stream = cudaStream_t(0)); + +void reflection_pad2d_out_forward(int32_t pad_h,int32_t pad_w,float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream = cudaStream_t(0)); + +void constant_pad2d_forward(dnnType *srcData,dnnType *dstData,int32_t input_h,int32_t input_w,int32_t output_h, + int32_t output_w,int32_t c,int32_t n,int32_t padT,int32_t padL,dnnType constant,cudaStream_t cudaStream = cudaStream_t(0)); + + #endif //KERNELS_H diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index 330ed37..1d98a59 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -1,61 +1,88 @@ -#include +#include "NvInfer.h" #include "../kernels.h" +#include +#include -class ActivationLeakyRT : public IPlugin { +namespace nvinfer1 { + class ActivationLeakyRT : public IPluginV2 { -public: - ActivationLeakyRT(float s) { - slope = s; - } + public: + explicit ActivationLeakyRT(float s); - ~ActivationLeakyRT(){ + ActivationLeakyRT(const void *data, size_t length); - } + ~ActivationLeakyRT(); - int getNbOutputs() const override { - return 1; - } + int getNbOutputs() const NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i 7 + int enqueue(int batchSize, void const *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + size_t getSerializationSize() const NOEXCEPT override; - activationLEAKYForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, slope, stream); - return 0; - } + void serialize(void *buffer) const NOEXCEPT override; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + + const char *getPluginType() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + void destroy() NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2 *clone() const NOEXCEPT override; + + int size; + float slope; + + private: + std::string mPluginNamespace; + }; + + class ActivationLeakyRTPluginCreator : public IPluginCreator { + public: + ActivationLeakyRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - virtual size_t getSerializationSize() override { - return 1*sizeof(int) + 1*sizeof(float); - } - - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } - - int size; - float slope; -}; + REGISTER_TENSORRT_PLUGIN(ActivationLeakyRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index 063931f..d972752 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -1,60 +1,88 @@ #include #include "../kernels.h" +#include +#include +#include -class ActivationLogisticRT : public IPlugin { +namespace nvinfer1 { -public: - ActivationLogisticRT() { + class ActivationLogisticRT : public IPluginV2 { + + public: + ActivationLogisticRT() ; + + ActivationLogisticRT(const void *data, size_t length) ; + + ~ActivationLogisticRT() ; + + int getNbOutputs() const NOEXCEPT override ; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - } + size_t getSerializationSize() const NOEXCEPT override ; - ~ActivationLogisticRT(){ + void serialize(void *buffer) const NOEXCEPT override ; - } + const char *getPluginType() const NOEXCEPT override ; - int getNbOutputs() const override { - return 1; - } + const char *getPluginVersion() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + void destroy() NOEXCEPT override ; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, stream); - return 0; - } + class ActivationLogisticRTPluginCreator : public IPluginCreator { + public: + ActivationLogisticRTPluginCreator() ; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - virtual size_t getSerializationSize() override { - return 1*sizeof(int); - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer); - tk::dnn::writeBUF(buf, size); - } + const char *getPluginNamespace() const NOEXCEPT override ; - int size; -}; + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ActivationLogisticRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index 5d660af..5b966cd 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -1,61 +1,82 @@ #include #include "../kernels.h" +#include +#include -class ActivationMishRT : public IPlugin { +namespace nvinfer1 { + class ActivationMishRT : public IPluginV2 { -public: - ActivationMishRT() { + public: + ActivationMishRT() ; + + ~ActivationMishRT() ; + + ActivationMishRT(const void *data, size_t length) ; - } + int getNbOutputs() const NOEXCEPT override ; - ~ActivationMishRT(){ + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int getNbOutputs() const override { - return 1; - } + int initialize() NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + void terminate() NOEXCEPT override ; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - int initialize() override { + size_t getSerializationSize() const NOEXCEPT override ; - return 0; - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void terminate() override { - } + const char *getPluginType() const NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + const char *getPluginVersion() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + void destroy() NOEXCEPT override { delete this; } - activationMishForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, stream); - return 0; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; + const char *getPluginNamespace() const NOEXCEPT override ; - virtual size_t getSerializationSize() override { - return 1*sizeof(int); - } + void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override ; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + IPluginV2 *clone() const NOEXCEPT override ; - int size; -}; + int size; + private: + std::string mPluginNamespace; + }; + + class ActivationMishRTPluginCreator : public IPluginCreator { + public: + ActivationMishRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ActivationMishRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index 50ceb81..1830945 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -1,63 +1,81 @@ #include #include "../kernels.h" +#include +#include +#include -class ActivationReLUCeiling : public IPlugin { +namespace nvinfer1 { + class ActivationReLUCeiling : public IPluginV2 { -public: - ActivationReLUCeiling(const float ceiling) { - this->ceiling = ceiling; - } + public: + explicit ActivationReLUCeiling(const float ceiling) ; - ~ActivationReLUCeiling(){ + ~ActivationReLUCeiling() ; - } + ActivationReLUCeiling(const void *data, size_t length) ; - int getNbOutputs() const override { - return 1; - } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + void serialize(void *buffer) const NOEXCEPT override ; - activationReLUCeilingForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, ceiling, stream); - return 0; - } + IPluginV2 *clone() const NOEXCEPT override ; + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - virtual size_t getSerializationSize() override { - return 1*sizeof(int) + 1*sizeof(float); - } + void destroy() NOEXCEPT override ; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, ceiling); - tk::dnn::writeBUF(buf, size); - assert(buf = a + getSerializationSize()); - - } + const char *getPluginType() const NOEXCEPT override ; - int size; - float ceiling; -}; + const char *getPluginVersion() const NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + int size; + float ceiling; + private: + std::string mPluginNamespace; + }; + + class ActivationReLUCeilingPluginCreator : public IPluginCreator { + public: + ActivationReLUCeilingPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + public: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ActivationReLUCeilingPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ConstantPaddingRT.h b/include/tkDNN/pluginsRT/ConstantPaddingRT.h new file mode 100644 index 0000000..15f4c0d --- /dev/null +++ b/include/tkDNN/pluginsRT/ConstantPaddingRT.h @@ -0,0 +1,109 @@ +// +// Created by perseusdg on 1/7/22. +// + +#ifndef _CONSTANTPADDINGRT_PLUGIN_H +#define _CONSTANTPADDINGRT_PLUGIN_H + +#include +#include +#include +#include +#include + +namespace nvinfer1{ + class ConstantPaddingRT : public IPluginV2Ext { + public: + ConstantPaddingRT(int32_t padH,int32_t padW,int32_t n,int32_t c,int32_t i_h,int32_t i_w,int32_t o_h,int32_t o_w,float constant); + + ConstantPaddingRT(const void *data,size_t length); + + ~ConstantPaddingRT(); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + + int32_t i_h,i_w,o_h,o_w,n,c,padH,padW; + float constant; + private: + std::string mPluginNamespace; + + }; + + class ConstantPaddingRTPluginCreator : public IPluginCreator { + public: + ConstantPaddingRTPluginCreator(); + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + + }; + + REGISTER_TENSORRT_PLUGIN(ConstantPaddingRTPluginCreator); +}; + + +#endif //TKDNN_CONSTANTPADDINGRT_H diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 711198f..9170e15 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -1,196 +1,137 @@ +#ifndef _DEFORMABLECONVRT_PLUGIN_H +#define _DEFORMABLECONVRT_PLUGIN_H + +#include +#include #include #include "../kernels.h" +#include + +namespace nvinfer1 { + class DeformableConvRT : public IPluginV2Ext { -class DeformableConvRT : public IPlugin { + public: + DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, + int deformableGroup, int i_n, int i_c, int i_h, int i_w, + int o_n, int o_c, int o_h, int o_w,std::vector data_H,std::vector bias2_H, + std::vector ones_d1_h,std::vector ones_d2_h,std::vector offsetH,std::vector maskH,int height_ones, + int width_ones,int dim_ones); + + ~DeformableConvRT(); + + DeformableConvRT(const void *data, size_t length) ; + + int getNbOutputs() const NOEXCEPT override ; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + cublasStatus_t stat; + cublasHandle_t handle{nullptr}; + int i_n, i_c, i_h, i_w; + int o_n, o_c, o_h, o_w; + int size; + int chunk_dim; + int kh, kw; + int sh, sw; + int ph, pw; + int deformableGroup; + int height_ones; + int width_ones; + int dim_ones; -public: - DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, - int deformableGroup, int i_n, int i_c, int i_h, int i_w, - int o_n, int o_c, int o_h, int o_w, - tk::dnn::DeformConv2d *deformable = nullptr) { - this->chunk_dim = chunk_dim; - this->kh = kh; - this->kw = kw; - this->sh = sh; - this->sw = sw; - this->ph = ph; - this->pw = pw; - this->deformableGroup = deformableGroup; - this->i_n = i_n; - this->i_c = i_c; - this->i_h = i_h; - this->i_w = i_w; - this->o_n = o_n; - this->o_c = o_c; - this->o_h = o_h; - this->o_w = o_w; - height_ones = (i_h + 2 * ph - (1 * (kh - 1) + 1)) / sh + 1; - width_ones = (i_w + 2 * pw - (1 * (kw - 1) + 1)) / sw + 1; - dim_ones = i_c * kh * kw * 1 * height_ones * width_ones; - - checkCuda( cudaMalloc(&data_d, i_c * o_c * kh * kw * 1 * sizeof(dnnType))); - checkCuda( cudaMalloc(&bias2_d, o_c*sizeof(dnnType))); - checkCuda( cudaMalloc(&ones_d1, height_ones * width_ones * sizeof(dnnType))); - checkCuda( cudaMalloc(&offset, 2*chunk_dim*sizeof(dnnType))); - checkCuda( cudaMalloc(&mask, chunk_dim*sizeof(dnnType))); - checkCuda( cudaMalloc(&ones_d2, dim_ones*sizeof(dnnType))); - if(deformable != nullptr) { - this->defRT = deformable; - checkCuda( cudaMemcpy(data_d, deformable->data_d, sizeof(dnnType)*i_c * o_c * kh * kw * 1, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(bias2_d, deformable->bias2_d, sizeof(dnnType)*o_c, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(ones_d1, deformable->ones_d1, sizeof(dnnType)*height_ones*width_ones, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(offset, deformable->offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(mask, deformable->mask, sizeof(dnnType)*chunk_dim, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(ones_d2, deformable->ones_d2, sizeof(dnnType)*dim_ones, cudaMemcpyDeviceToDevice) ); - } - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - FatalError("CUBLAS initialization failed\n"); - } - - ~DeformableConvRT() { - checkCuda( cudaFree(data_d) ); - checkCuda( cudaFree(bias2_d) ); - checkCuda( cudaFree(ones_d1) ); - checkCuda( cudaFree(offset) ); - checkCuda( cudaFree(mask) ); - checkCuda( cudaFree(ones_d2) ); - cublasDestroy(handle); - } - - int getNbOutputs() const override { - return 1; - } - - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { } - - int initialize() override { - return 0; - } - - virtual void terminate() override { } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); - - // split conv2d outputs into offset to mask - for(int b=0; b(outputs[0]), ones_d2, - kh, kw, - sh, sw, - ph, pw, - 1, 1, - deformableGroup, b, - i_n, i_c, i_h, i_w, - o_n, o_c, o_h, o_w, - chunk_dim); - } - return 0; - } + std::vector data_d_v; + std::vector bias2_d_v; + std::vector ones_d1_v; + std::vector offset_v; + std::vector mask_v; + std::vector ones_d2_v; + dnnType* data_d; + dnnType* bias2_d; + dnnType* ones_d1; + dnnType* offset; + dnnType* mask; + dnnType* ones_d2; + // dnnType *input_n; + // dnnType *offset_n; + // dnnType *mask_n; + // dnnType *output_n; - virtual size_t getSerializationSize() override { - return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + - o_c * sizeof(dnnType) + height_ones * width_ones * sizeof(dnnType) + dim_ones * sizeof(dnnType); - } + tk::dnn::DeformConv2d *defRT; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, chunk_dim); - tk::dnn::writeBUF(buf, kh); - tk::dnn::writeBUF(buf, kw); - tk::dnn::writeBUF(buf, sh); - tk::dnn::writeBUF(buf, sw); - tk::dnn::writeBUF(buf, ph); - tk::dnn::writeBUF(buf, pw); - tk::dnn::writeBUF(buf, deformableGroup); - tk::dnn::writeBUF(buf, i_n); - tk::dnn::writeBUF(buf, i_c); - tk::dnn::writeBUF(buf, i_h); - tk::dnn::writeBUF(buf, i_w); - tk::dnn::writeBUF(buf, o_n); - tk::dnn::writeBUF(buf, o_c); - tk::dnn::writeBUF(buf, o_h); - tk::dnn::writeBUF(buf, o_w); - dnnType *aus = new dnnType[chunk_dim*2]; - checkCuda( cudaMemcpy(aus, offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToHost) ); - for(int i=0; i mPluginAttributes; + std::string mPluginNamespace; + }; + REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); }; +#endif diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 51aa1ab..f7ec495 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,81 +1,100 @@ +#ifndef _FLATTENCONCATRT_PLUGIN_H +#define _FLATTENCONCATRT_PLUGIN_H + #include +#include +#include +#include +namespace nvinfer1 { + class FlattenConcatRT : public IPluginV2Ext { -class FlattenConcatRT : public IPlugin { + public: + FlattenConcatRT(int c,int h,int w,int rows,int cols) ; -public: - FlattenConcatRT() { - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) { - printf ("CUBLAS initialization failed\n"); - return; - } - } + FlattenConcatRT(const void *data, size_t length) ; - ~FlattenConcatRT(){ + ~FlattenConcatRT() ; - } + int getNbOutputs() const NOEXCEPT override ; - int getNbOutputs() const override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; - } + int initialize() NOEXCEPT override ; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - assert(nbOutputs == 1 && nbInputs ==1); - rows = inputDims[0].d[0]; - cols = inputDims[0].d[1] * inputDims[0].d[2]; - c = inputDims[0].d[0] * inputDims[0].d[1] * inputDims[0].d[2]; - h = 1; - w = 1; - } + void terminate() NOEXCEPT override ; - int initialize() override { - return 0; - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual void terminate() override { - checkERROR(cublasDestroy(handle)); - } +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + void serialize(void *buffer) const NOEXCEPT override ; - checkERROR( cublasSetStream(handle, stream) ); - for(int i=0; i(buffer),*a = buf; - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - tk::dnn::writeBUF(buf, rows); - tk::dnn::writeBUF(buf, cols); - assert(buf == a + getSerializationSize()); - } + const char *getPluginNamespace() const NOEXCEPT override ; - int c, h, w; - int rows, cols; - cublasStatus_t stat; - cublasHandle_t handle; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + + int c, h, w; + int rows, cols; + cublasHandle_t handle{nullptr}; + private: + std::string mPluginNamespace; + }; + + class FlattenConcatRTPluginCreator : public IPluginCreator { + public: + FlattenConcatRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(FlattenConcatRTPluginCreator); }; +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 0899a34..95e15f4 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -1,75 +1,105 @@ #include #include "../kernels.h" - -class MaxPoolFixedSizeRT : public IPlugin { - -public: - MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) { - this->c = c; - this->h = h; - this->w = w; - this->n = n; - this->stride_H = strideH; - this->stride_W = strideW; - this->winSize = winSize; - this->padding = padding; - } - - ~MaxPoolFixedSizeRT(){ - } - - int getNbOutputs() const override { - return 1; - } - - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{this->c, this->h, this->w}; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - } - - int initialize() override { - return 0; - } - - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - //std::cout<n<<" "<c<<" "<h<<" "<w<<" "<stride_H<<" "<stride_W<<" "<winSize<<" "<padding<(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); - return 0; - } +#include +#include +#include - virtual size_t getSerializationSize() override { - return 8*sizeof(int); - } +namespace nvinfer1 { + class MaxPoolFixedSizeRT : public IPluginV2Ext { - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; + public: + MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) ; - tk::dnn::writeBUF(buf, this->c); - tk::dnn::writeBUF(buf, this->h); - tk::dnn::writeBUF(buf, this->w); - tk::dnn::writeBUF(buf, this->n); - tk::dnn::writeBUF(buf, this->stride_H); - tk::dnn::writeBUF(buf, this->stride_W); - tk::dnn::writeBUF(buf, this->winSize); - tk::dnn::writeBUF(buf, this->padding); - assert(buf == a + getSerializationSize()); - } + MaxPoolFixedSizeRT(const void *data, size_t length) ; - int n, c, h, w; - int stride_H, stride_W; - int winSize; - int padding; + ~MaxPoolFixedSizeRT() ; + + int getNbOutputs() const NOEXCEPT override ; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + + int n, c, h, w; + int stride_H, stride_W; + int winSize; + int padding; + + private: + std::string mPluginNamespace; + }; + + class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator { + public: + MaxPoolFixedSizeRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + + }; + + REGISTER_TENSORRT_PLUGIN(MaxPoolFixedSizeRTPluginCreator); }; diff --git a/include/tkDNN/pluginsRT/ReflectionPadding.h b/include/tkDNN/pluginsRT/ReflectionPadding.h new file mode 100644 index 0000000..7b13710 --- /dev/null +++ b/include/tkDNN/pluginsRT/ReflectionPadding.h @@ -0,0 +1,101 @@ +#ifndef _REFLECTIONPADDINGRT_PLUGIN_H +#define _REFLECTIONPADDINGRT_PLUGIN_H + +#include +#include +#include +#include +#include + +namespace nvinfer1{ + class ReflectionPaddingRT : public IPluginV2Ext { + public: + ReflectionPaddingRT(int32_t padH,int32_t padW,int32_t input_h,int32_t input_w,int32_t output_h,int32_t output_w,int32_t c,int32_t n); + + ReflectionPaddingRT(const void *data,size_t length); + + ~ReflectionPaddingRT(); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + + int32_t padH,padW,input_h,input_w,output_h,output_w,n,c; + private: + std::string mPluginNamespace; + + }; + + class ReflectionPaddingRTPluginCreator : public IPluginCreator { + public: + ReflectionPaddingRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ReflectionPaddingRTPluginCreator); +}; +#endif + diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index 8487652..7f7157c 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -1,95 +1,110 @@ +#ifndef _REGIONRT_PLUGIN_H +#define _REGIONRT_PLUGIN_H #include #include "../kernels.h" +#include +#include +#include -class RegionRT : public IPlugin { +namespace nvinfer1 { + class RegionRT : public IPluginV2Ext { -public: - RegionRT(int classes, int coords, int num) { + public: + RegionRT(int classes, int coords, int num,int c,int h,int w); - this->classes = classes; - this->coords = coords; - this->num = num; - } + ~RegionRT() ; - ~RegionRT(){ + RegionRT(const void *data, size_t length) ; - } + int getNbOutputs() const NOEXCEPT override ; - int getNbOutputs() const override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } - - int initialize() override { - - return 0; - } - - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - - for (int b = 0; b < batchSize; ++b){ - for(int n = 0; n < num; ++n){ - int index = entry_index(b, n*w*h, 0); - activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); - - index = entry_index(b, n*w*h, coords); - activationLOGISTICForward(srcData + index, dstData + index, w*h, stream); - } - } - - //softmax start - int index = entry_index(0, 0, coords + 1); - softmaxForward( srcData + index, classes, batchSize*num, - (c*h*w)/num, - w*h, 1, w*h, 1, dstData + index, stream); - - return 0; - } + int initialize() NOEXCEPT override ; - virtual size_t getSerializationSize() override { - return 6*sizeof(int); - } + void terminate() NOEXCEPT override ; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, classes); - tk::dnn::writeBUF(buf, coords); - tk::dnn::writeBUF(buf, num); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - int c, h, w; - int classes, coords, num; +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - int entry_index(int batch, int location, int entry) { - int n = location / (w*h); - int loc = location % (w*h); - return batch*c*h*w + n*w*h*(coords+classes+1) + entry*w*h + loc; - } + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + IPluginV2Ext *clone() const NOEXCEPT override ; + int c, h, w; + int classes, coords, num; + + int entry_index(int batch, int location, int entry) { + int n = location / (w * h); + int loc = location % (w * h); + return batch * c * h * w + n * w * h * (coords + classes + 1) + entry * w * h + loc; + } + + private: + std::string mPluginNamespace; + }; + + class RegionRTPluginCreator : public IPluginCreator { + public: + RegionRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(RegionRTPluginCreator); }; + +#endif diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index c1b529a..be163a5 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -1,64 +1,98 @@ #include #include "../kernels.h" +#include +#include -class ReorgRT : public IPlugin { +namespace nvinfer1 { + class ReorgRT : public IPluginV2Ext { -public: - ReorgRT(int stride) { - this->stride = stride; - } + public: + ReorgRT(int stride,int c,int h,int w); - ~ReorgRT(){ + ~ReorgRT(); - } + ReorgRT(const void *data, size_t length); - int getNbOutputs() const override { - return 1; - } + int getNbOutputs() const NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + int initialize() NOEXCEPT override; - int initialize() override { + void terminate() NOEXCEPT override; - return 0; - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - reorgForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), - batchSize, c, h, w, stride, stream); - return 0; - } +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - virtual size_t getSerializationSize() override { - return 4*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, stride); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + void serialize(void *buffer) const NOEXCEPT override; - int c, h, w, stride; + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + + const char *getPluginType() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + void destroy() NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2Ext *clone() const NOEXCEPT override; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + int c, h, w, stride; + private: + std::string mPluginNamespace; + }; + + class ReorgRTPluginCreator : public IPluginCreator { + public: + ReorgRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + + const char *getPluginName() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ReorgRTPluginCreator); }; + diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index 37017c7..e56c79c 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -1,62 +1,102 @@ +#ifndef _RESHAPERT_PLUGIN_H +#define _RESHAPERT_PLUGIN_H + #include - -class ReshapeRT : public IPlugin { - -public: - ReshapeRT(dataDim_t new_dim) { - n = new_dim.n; - c = new_dim.c; - h = new_dim.h; - w = new_dim.w; - } - - ~ReshapeRT(){ - - } - - int getNbOutputs() const override { - return 1; - } - - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{ c,h,w}; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - } - - int initialize() override { - return 0; - } - - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - return 0; - } +#include +#include +#include +using namespace tk::dnn; - virtual size_t getSerializationSize() override { - return 4*sizeof(int); - } +namespace nvinfer1 { + class ReshapeRT : public IPluginV2Ext { - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a = buf; - tk::dnn::writeBUF(buf, n); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + public: + ReshapeRT(int n,int c,int h,int w) ; - int n, c, h, w; + ReshapeRT(const void *data, size_t length) ; + + ~ReshapeRT() ; + + int getNbOutputs() const NOEXCEPT override ; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + int n, c, h, w; + private: + std::string mPluginNamespace; + }; + + class ReshapeRTPluginCreator : public IPluginCreator { + public: + ReshapeRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ReshapeRTPluginCreator); }; +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index cde52bf..750057e 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -1,68 +1,104 @@ #include #include "../kernels.h" +#include +#include +#include -class ResizeLayerRT : public IPlugin { +namespace nvinfer1 { -public: - ResizeLayerRT(int c, int h, int w) { - o_c = c; - o_h = h; - o_w = w; - } + class ResizeLayerRT : public IPluginV2Ext { - ~ResizeLayerRT(){ - } + public: + ResizeLayerRT(int oc, int oh, int ow,int ic,int ih,int iw) ; - int getNbOutputs() const override { - return 1; - } + ResizeLayerRT(const void *data, size_t length) ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{o_c, o_h, o_w}; - } + ~ResizeLayerRT() ; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - i_c = inputDims[0].d[0]; - i_h = inputDims[0].d[1]; - i_w = inputDims[0].d[2]; - } + int getNbOutputs() const NOEXCEPT override ; - int initialize() override { - return 0; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - virtual void terminate() override { - } + int initialize() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + void terminate() NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - // printf("%d %d %d %d %d %d\n", i_c, i_w, i_h, o_c, o_w, o_h); - resizeForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), - batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); - return 0; - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + int i_c, i_h, i_w, o_c, o_h, o_w; + + private: + std::string mPluginNamespace; + }; + + class ResizeLayerRTPluginCreator : public IPluginCreator { + public: + ResizeLayerRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - virtual size_t getSerializationSize() override { - return 6*sizeof(int); - } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, o_c); - tk::dnn::writeBUF(buf, o_h); - tk::dnn::writeBUF(buf, o_w); + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; - tk::dnn::writeBUF(buf, i_c); - tk::dnn::writeBUF(buf, i_h); - tk::dnn::writeBUF(buf, i_w); - assert(buf == a + getSerializationSize()); - } + }; - int i_c, i_h, i_w, o_c, o_h, o_w; + REGISTER_TENSORRT_PLUGIN(ResizeLayerRTPluginCreator); }; + diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 5a8c170..499b9da 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -1,96 +1,90 @@ #include #include "../kernels.h" +#include +#include -class RouteRT : public IPlugin { +namespace nvinfer1 { + class RouteRT : public IPluginV2 { - /** - THIS IS NOT USED ANYMORE - */ + /** + THIS IS NOT USED ANYMORE + */ -public: - RouteRT(int groups, int group_id) { - this->groups = groups; - this->group_id = group_id; - } + public: + RouteRT(int groups, int group_id) ; - ~RouteRT(){ + ~RouteRT() ; - } + RouteRT(const void *data, size_t length) ; - int getNbOutputs() const override { - return 1; - } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - int out_c = 0; - for(int i=0; i 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - dnnType *dstData = reinterpret_cast(outputs[0]); + size_t getSerializationSize() const NOEXCEPT override ; - for(int b=0; b(inputs[i]); - int in_dim = c_in[i]*h*w; - int part_in_dim = in_dim / this->groups; - checkCuda( cudaMemcpyAsync(dstData + b*c*w*h + offset, input + b*c*w*h*groups + this->group_id*part_in_dim, part_in_dim*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream) ); - offset += part_in_dim; - } - } + void serialize(void *buffer) const NOEXCEPT override ; - return 0; - } + const char *getPluginType() const NOEXCEPT override ; + const char *getPluginVersion() const NOEXCEPT override ; - virtual size_t getSerializationSize() override { - return (6+MAX_INPUTS)*sizeof(int); - } + void destroy() NOEXCEPT override ; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, groups); - tk::dnn::writeBUF(buf, group_id); - tk::dnn::writeBUF(buf, in); - for(int i=0; i mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(RouteRTPluginCreator); }; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 04091ac..0c01b9d 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -1,77 +1,109 @@ +#ifndef _SHORTCUTRT_PLUGIN_H +#define _SHORTCUTRT_PLUGIN_H + #include #include "../kernels.h" - -class ShortcutRT : public IPlugin { - -public: - ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - this->bc = bdim.c; - this->bh = bdim.h; - this->bw = bdim.w; - this->mul = mul; - } - - ~ShortcutRT(){ - - } - - int getNbOutputs() const override { - return 1; - } - - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } - - int initialize() override { - - return 0; - } - - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - shortcutForward(srcDataBack, dstData, batchSize, c, h, w, 1, batchSize, bc, bh, bw, 1, mul, stream); - - return 0; - } +#include +#include +#include - virtual size_t getSerializationSize() override { - return 6*sizeof(int) + sizeof(bool); - } +namespace nvinfer1 { - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, bc); - tk::dnn::writeBUF(buf, bh); - tk::dnn::writeBUF(buf, bw); - tk::dnn::writeBUF(buf, mul); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - - } + class ShortcutRT : public IPluginV2Ext { + + public: + ShortcutRT(int bc,int bh,int bw,int c,int h,int w ,bool mul); + + ~ShortcutRT(); + + ShortcutRT(const void *data, size_t length); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, int32_t nbOutputs, + DataType const *inputTypes, DataType const *outputTypes, bool const *inputIsBroadcast, + bool const *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch (int32_t outputIndex, bool const *inputIsBroadcasted, int32_t nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch (int32_t inputIndex) const NOEXCEPT override; + + void attachToContext (cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT override; + + void detachFromContext () NOEXCEPT override; + + DataType getOutputDataType(int32_t index, nvinfer1::DataType const *inputTypes, int32_t nbInputs) const NOEXCEPT override; + + int initialize() NOEXCEPT override; + + void terminate() NOEXCEPT override; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + + size_t getSerializationSize() const NOEXCEPT override; + + void serialize(void *buffer) const NOEXCEPT override; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + + const char *getPluginType() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + void destroy() NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2Ext *clone() const NOEXCEPT override; + + int c, h, w; + int bc, bh, bw,bl; + bool mul; + tk::dnn::dataDim_t bDim; + private: + std::string mPluginNamespace; + }; + + + class ShortcutRTPluginCreator : public IPluginCreator { + public: + ShortcutRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + + const char *getPluginName() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + public: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ShortcutRTPluginCreator); - int c, h, w; - int bc, bh, bw; - bool mul; }; + +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index a11d7b4..4379ee7 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -1,66 +1,103 @@ +#ifndef _UPSAMPLERT_PLUGIN_H +#define _UPSAMPLERT_PLUGIN_H + #include #include "../kernels.h" +#include +#include -class UpsampleRT : public IPlugin { +namespace nvinfer1 { -public: - UpsampleRT(int stride) { - this->stride = stride; - } + class UpsampleRT : public IPluginV2Ext { - ~UpsampleRT(){ + public: + UpsampleRT(int stride,int c,int h,int w); - } + UpsampleRT(const void *data, size_t length); - int getNbOutputs() const override { - return 1; - } + ~UpsampleRT(); - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); - } + int getNbOutputs() const NOEXCEPT override; - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - int initialize() override { + int initialize() NOEXCEPT override; - return 0; - } + void terminate() NOEXCEPT override; - virtual void terminate() override { - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); - upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); - return 0; - } +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - virtual size_t getSerializationSize() override { - return 4*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override; - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, stride); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + void serialize(void *buffer) const NOEXCEPT override; - int c, h, w, stride; -}; + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + + const char *getPluginType() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + void destroy() NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + bool isOutputBroadcastAcrossBatch (int32_t outputIndex, bool const *inputIsBroadcasted, int32_t nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch (int32_t inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, int32_t nbOutputs, + DataType const *inputTypes, DataType const *outputTypes, bool const *inputIsBroadcast, + bool const *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT override; + + void attachToContext (cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT override; + + void detachFromContext () NOEXCEPT override; + + DataType getOutputDataType (int32_t index, nvinfer1::DataType const *inputTypes, int32_t nbInputs) const NOEXCEPT override; + + + int c, h, w, stride; + private: + std::string mPluginNamespace; + }; + + class UpsampleRTPluginCreator : public IPluginCreator { + public: + UpsampleRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + + const char *getPluginName() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); + }; + +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 5ffe39c..352a0cb 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,143 +1,124 @@ +#ifndef _YOLORT_PLUGIN_H +#define _YOLORT_PLUGIN_H + #include +#include #include "../kernels.h" +#include +#include #define YOLORT_CLASSNAME_W 256 -class YoloRT : public IPlugin { +namespace nvinfer1 { + class YoloRT : public IPluginV2Ext { + + public: + YoloRT(int classes, int num,int c,int h,int w, int n_masks = 3, float scale_xy = 1, + float nms_thresh = 0.45, int nms_kind = 0, int new_coords = 0); + + YoloRT(const void *data, size_t length); + + ~YoloRT(); + int getNbOutputs() const NOEXCEPT override; -public: - YoloRT(int classes, int num, tk::dnn::Yolo *yolo = nullptr, int n_masks=3, float scale_xy=1, float nms_thresh=0.45, int nms_kind=0, int new_coords=0) { + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - this->classes = classes; - this->num = num; - this->n_masks = n_masks; - this->scaleXY = scale_xy; - this->nms_thresh = nms_thresh; - this->nms_kind = nms_kind; - this->new_coords = new_coords; + int initialize() NOEXCEPT override; - mask = new dnnType[n_masks]; - bias = new dnnType[num*n_masks*2]; - if(yolo != nullptr) { - memcpy(mask, yolo->mask_h, sizeof(dnnType)*n_masks); - memcpy(bias, yolo->bias_h, sizeof(dnnType)*num*n_masks*2); - classesNames = yolo->classesNames; - } - } + void terminate() NOEXCEPT override; - ~YoloRT(){ - - } - - int getNbOutputs() const override { - return 1; - } - - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } - - int initialize() override { - - return 0; - } - - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - for (int b = 0; b < batchSize; ++b){ - for(int n = 0; n < n_masks; ++n){ - int index = entry_index(b, n*w*h, 0); - if (new_coords == 1){ - if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1); - } - else{ - activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); //x,y +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif - if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1); - index = entry_index(b, n*w*h, 4); - activationLOGISTICForward(srcData + index, dstData + index, (1+classes)*w*h, stream); - } - } + size_t getSerializationSize() const NOEXCEPT override; + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + + void serialize(void *buffer) const NOEXCEPT override; + + const char *getPluginType() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + void destroy() NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2Ext *clone() const NOEXCEPT override; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + + int c, h, w; + int classes, num, n_masks; + float scaleXY; + float nms_thresh; + int nms_kind; + int new_coords; + int NUM = 0; + std::vector classesNames; + + + int entry_index(int batch, int location, int entry) { + int n = location / (w * h); + int loc = location % (w * h); + return batch * c * h * w + n * w * h * (4 + classes + 1) + entry * w * h + loc; } - //std::cout<<"YOLO END\n"; - return 0; - } + private: + std::string mPluginNamespace; + }; - virtual size_t getSerializationSize() override { - return 8*sizeof(int) + 2*sizeof(float)+ n_masks*sizeof(dnnType) + num*n_masks*2*sizeof(dnnType) + YOLORT_CLASSNAME_W*classes*sizeof(char); - } + class YoloRTPluginCreator : public IPluginCreator { + public: + YoloRTPluginCreator(); - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; - tk::dnn::writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; - tk::dnn::writeBUF(buf, n_masks); //std::cout << "N_Masks" << n_masks << std::endl; - tk::dnn::writeBUF(buf, scaleXY); //std::cout << "ScaleXY :" << scaleXY << std::endl; - tk::dnn::writeBUF(buf, nms_thresh); //std::cout << "nms_thresh :" << nms_thresh << std::endl; - tk::dnn::writeBUF(buf, nms_kind); //std::cout << "nms_kind : " << nms_kind << std::endl; - tk::dnn::writeBUF(buf, new_coords); //std::cout << "new_coords : " << new_coords << std::endl; - tk::dnn::writeBUF(buf, c); //std::cout << "C : " << c << std::endl; - tk::dnn::writeBUF(buf, h); //std::cout << "H : " << h << std::endl; - tk::dnn::writeBUF(buf, w); //std::cout << "C : " << c << std::endl; - for (int i = 0; i < n_masks; i++) - { - tk::dnn::writeBUF(buf, mask[i]); //std::cout << "mask[i] : " << mask[i] << std::endl; - } - for (int i = 0; i < n_masks * 2 * num; i++) - { - tk::dnn::writeBUF(buf, bias[i]); //std::cout << "bias[i] : " << bias[i] << std::endl; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - // save classes names - for(int i=0; i classesNames; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - dnnType *mask; - dnnType *bias; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; - int entry_index(int batch, int location, int entry) { - int n = location / (w*h); - int loc = location % (w*h); - return batch*c*h*w + n*w*h*(4+classes+1) + entry*w*h + loc; - } + const char *getPluginName() const NOEXCEPT override; + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(YoloRTPluginCreator); }; +#endif \ No newline at end of file diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 4965a7a..055ea67 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -6,16 +6,18 @@ #include #include #include +#include + #include "cuda.h" #include "cuda_runtime_api.h" #include #include +#include #ifdef __linux__ #include - #endif #include @@ -23,8 +25,30 @@ #include + + +#if NV_TENSORRT_MAJOR > 7 +#define NOEXCEPT noexcept +#else +#define NOEXCEPT +#endif + + #define dnnType float +template void writeBUF(char*& buffer, const T& val) +{ + *reinterpret_cast(buffer) = val; + buffer += sizeof(T); +} + +template T readBUF(const char*& buffer) +{ + T val = *reinterpret_cast(buffer); + buffer += sizeof(T); + return val; +} + // Colored output #define COL_END "\033[0m" diff --git a/scripts/install_OpenCV4.sh b/scripts/install_OpenCV4.sh index f57c87b..0871fa3 100644 --- a/scripts/install_OpenCV4.sh +++ b/scripts/install_OpenCV4.sh @@ -27,17 +27,21 @@ sudo apt-get install -y build-essential \ libgstreamer1.0-dev \ libgstreamer-plugins-base1.0-dev \ libdc1394-22-dev \ - libavresample-dev + libavresample-dev \ + libtbb-dev \ git clone https://github.com/opencv/opencv.git +cd opencv && git checkout 4.5.4 && cd .. git clone https://github.com/opencv/opencv_contrib.git +cd opencv_contrib && git checkout 4.5.4 && cd .. + python3 -m venv opencv4 source opencv4/bin/activate pip install wheel pip install numpy -cd opencv && mkdir build && cd build +cd opencv && mkdir build && cd build cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ @@ -56,6 +60,8 @@ cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ -D WITH_TBB=ON \ + -D WITH_OPENGL=ON \ + -D WITH_VULKAN=ON \ ../ make -j4 diff --git a/src/Activation.cpp b/src/Activation.cpp index 0b113a7..947b019 100644 --- a/src/Activation.cpp +++ b/src/Activation.cpp @@ -56,6 +56,9 @@ dnnType* Activation::infer(dataDim_t &dim, dnnType* srcData) { else if(act_mode == ACTIVATION_LOGISTIC) { activationLOGISTICForward(srcData, dstData, dim.tot()); + } else if(act_mode == ACTIVATION_ELU) { + activationELUForward(srcData, dstData, dim.tot()); + } else { dnnType alpha = dnnType(1); dnnType beta = dnnType(0); diff --git a/src/CenterTrack.cpp b/src/CenterTrack.cpp index 991ff69..55bf82f 100644 --- a/src/CenterTrack.cpp +++ b/src/CenterTrack.cpp @@ -17,7 +17,6 @@ bool CenterTrack::init(const std::string& tensor_path, const int n_classes, cons init_pre_inf(); init_postprocessing(); init_visualization(n_classes); - return true; } @@ -61,7 +60,6 @@ bool CenterTrack::init_preprocessing(){ checkCuda( cudaMalloc(&input_d, sizeof(dnnType)*netRT->input_dim.tot() * nBatches)); checkCuda( cudaMalloc(&input_pre_inf_d, sizeof(dnnType)*dim.tot())); checkCuda( cudaMalloc(&d_ptrs, dim.tot() * sizeof(float)) ); - return true; } @@ -206,7 +204,6 @@ bool CenterTrack::init_postprocessing(){ trRes.resize(nBatches); countTr.resize(nBatches, 0); trackId.resize(nBatches, 0); - return true; } @@ -316,7 +313,7 @@ void CenterTrack::preprocess(cv::Mat &frame, const int bi){ } float c[] = {new_width / 2.0f, new_height /2.0f}; - float s[] = {float(dim.w), float(dim.h)}; + float s[] = {static_cast(dim.w), static_cast(dim.h)}; // float s = new_width >= new_height ? new_width : new_height; // ----------- get_affine_transform // rot_rad = pi * 0 / 100 --> 0 @@ -421,9 +418,9 @@ cv::Mat CenterTrack::transform_preds_with_trans(float x1, float x2){ } void CenterTrack::tracking(const int bi) { - float item_size[countDet]; - int item_cl[countDet]; - float dets[2*countDet]; + std::vector item_size(countDet); + std::vector item_cl(countDet); + std::vector dets(2*countDet); for(int i=0; i(0,0) - detRes[i].bb0.at(0,0)) * (detRes[i].bb1.at(0,1) - detRes[i].bb0.at(0,1)); @@ -432,9 +429,9 @@ void CenterTrack::tracking(const int bi) { dets[i*2+1] = detRes[i].ct.at(0,1); } - float track_size[countTr[bi]]; - int track_cl[countTr[bi]]; - float tracks[2*countTr[bi]]; + std::vector track_size(countTr[bi]); + std::vector track_cl(countTr[bi]); + std::vector tracks(2*countTr[bi]); for(int i=0; i(0,0) - trRes[bi][i].det_res.bb0.at(0,0)) * (trRes[bi][i].det_res.bb1.at(0,1) - trRes[bi][i].det_res.bb0.at(0,1)); @@ -442,7 +439,7 @@ void CenterTrack::tracking(const int bi) { tracks[i*2] = trRes[bi][i].det_res.ct.at(0,0); tracks[i*2+1] = trRes[bi][i].det_res.ct.at(0,1); } - float dist[countTr[bi]*countDet]; + std::vector dist(countTr[bi]*countDet); bool invalid; for(int i=0; i matched_indices(2*countTr[bi]); float min_tr; int min_idtr = -1; for(int i=0; i unmatched_dets(countDet); for(int i=0; i unmatched_tracks(countTr[bi]); for(int i=0; i(2,0)=dst2.at(1,0) + (-dst2.at(0,1)+dst2.at(1,1) ); dst2.at(2,1)=dst2.at(1,1) + (dst2.at(0,0)-dst2.at(1,0) ); + return true; return true; } @@ -348,21 +349,21 @@ void CenternetDetection::postprocess(const int bi, const bool mAP){ new_pt1.at(0,0)=static_cast(trans2.at(0,0))*bbx0[i] + static_cast(trans2.at(0,1))*bby0[i] + static_cast(trans2.at(0,2))*1.0; - new_pt1.at(0,1)=static_cast(trans2.at(1,0))*bbx0[i] + + new_pt1.at(1,0)=static_cast(trans2.at(1,0))*bbx0[i] + static_cast(trans2.at(1,1))*bby0[i] + static_cast(trans2.at(1,2))*1.0; new_pt2.at(0,0)=static_cast(trans2.at(0,0))*bbx1[i] + static_cast(trans2.at(0,1))*bby1[i] + static_cast(trans2.at(0,2))*1.0; - new_pt2.at(0,1)=static_cast(trans2.at(1,0))*bbx1[i] + + new_pt2.at(1,0)=static_cast(trans2.at(1,0))*bbx1[i] + static_cast(trans2.at(1,1))*bby1[i] + static_cast(trans2.at(1,2))*1.0; target_coords[i*4] = new_pt1.at(0,0); - target_coords[i*4+1] = new_pt1.at(0,1); + target_coords[i*4+1] = new_pt1.at(1,0); target_coords[i*4+2] = new_pt2.at(0,0); - target_coords[i*4+3] = new_pt2.at(0,1); + target_coords[i*4+3] = new_pt2.at(1,0); } detected.clear(); diff --git a/src/CenternetDetection3D.cpp b/src/CenternetDetection3D.cpp index 14f674d..fd09132 100644 --- a/src/CenternetDetection3D.cpp +++ b/src/CenternetDetection3D.cpp @@ -167,7 +167,6 @@ bool CenternetDetection3D::init(const std::string& tensor_path, const int n_clas faceId.push_back({2,3,7,6}); faceId.push_back({3,0,4,7}); // ([[0,1,5,4], [1,2,6, 5], [2,3,7,6], [3,0,4,7]]); - return true; } diff --git a/src/DarknetParser.cpp b/src/DarknetParser.cpp index 69b6b29..3333afd 100644 --- a/src/DarknetParser.cpp +++ b/src/DarknetParser.cpp @@ -17,8 +17,8 @@ namespace tk { namespace dnn { if(sep == std::string::npos) return false; - name = line.substr(0, sep); - value = line.substr(sep+1, line.size() - (sep+1)); + name = line.substr(0, sep); + value = line.substr(sep+1, line.size() - (sep+1)); return true; } @@ -32,6 +32,16 @@ namespace tk { namespace dnn { return values; } + std::vector fromStringToFloatVec(const std::string& line, const char delimiter){ + std::stringstream linestream(line); + std::string value; + std::vector values; + + while(getline(linestream,value,delimiter)) + values.push_back(std::stof(value)); + return values; + } + bool darknetParseFields(const std::string& line, darknetFields_t& fields){ std::string name,value; @@ -268,7 +278,133 @@ namespace tk { namespace dnn { } return net; } - - + std::vector noYolosLine(const std::string &cfg_file){ + std::ifstream if_cfg(cfg_file); + if(!if_cfg.is_open()) + FatalError("cloud not open cfg file: " + cfg_file); + std::string line; + std::vector lineNo; + int count = 0; + while(std::getline(if_cfg,line)){ + std::size_t found = line.find("#"); + if ( found != std::string::npos ) { + line = line.substr(0, found); + } + // skip empty lines + if(line.empty()) + continue; + if(line == "[yolo]"){ + lineNo.push_back(count); + + + } + count++; + } + return lineNo; + } + void loadYoloInfo(const std::string &cfg_file,int lineNo,std::vector &mask,std::vector &anchors,int &num,int &classes,float &nms_thresh,int &nms_kind,int &coords){ + std::vector maskTemp,anchorsTemp; + int classesTemp,numTemp,nmsKindTemp; + int new_coordsTemp=0; + float nmsThreshTemp=0.45; + + std::ifstream if_cfg(cfg_file); + if(!if_cfg.is_open()) + FatalError("cloud not open cfg file: " + cfg_file); + std::string line; + int count = 0; + while(std::getline(if_cfg,line)){ + std::string name,value; + std::size_t found = line.find("#"); + if ( found != std::string::npos ) { + line = line.substr(0, found); + } + // skip empty lines + if(line.empty()) + continue; + if(count > lineNo && count <=lineNo+30){ + divideNameAndValue(line,name,value); + if(name == "mask "){ + maskTemp = fromStringToFloatVec(value,','); + } + if(name == "anchors "){ + anchorsTemp = fromStringToFloatVec(value,','); + } + if(name == "classes"){ + classesTemp = std::stoi(value); + } + if(name == "num"){ + numTemp = std::stoi(value); + } + if(name == "nms_kind"){ + if(value == "greedynms"){ + nmsKindTemp = 0; + }else if(value == "diounms"){ + nmsKindTemp=1; + } + else{ + std::cout<<"NMS NOT SUPPORTED DEFAULTING TO GREEDYNMS"<h = 1; + this->w = 1; + this->rows = input_dim.c; + this->cols = input_dim.h * input_dim.w; + this->c = input_dim.w * input_dim.h * input_dim.c; } Flatten::~Flatten() { diff --git a/src/Int8BatchStream.cpp b/src/Int8BatchStream.cpp index fdc1db2..a211a65 100644 --- a/src/Int8BatchStream.cpp +++ b/src/Int8BatchStream.cpp @@ -8,14 +8,14 @@ BatchStream::BatchStream(tk::dnn::dataDim_t dim, int batchSize, int maxBatches, const std::string& fileimglist, const std::string& filelabellist) { mBatchSize = batchSize; mMaxBatches = maxBatches; - mDims = nvinfer1::DimsNCHW{ dim.n, dim.c, dim.h, dim.w }; + mDims = nvinfer1::Dims4{ dim.n, dim.c, dim.h, dim.w }; mHeight = dim.h; mWidth = dim.w; - mImageSize = mDims.c()*mDims.h()*mDims.w(); + mImageSize = mDims.d[1]*mDims.d[2]*mDims.d[3]; mBatch.resize(mBatchSize*mImageSize, 0); mLabels.resize(mBatchSize, 0); - mFileBatch.resize(mDims.n()*mImageSize, 0); - mFileLabels.resize(mDims.n(), 0); + mFileBatch.resize(mDims.d[0]*mImageSize, 0); + mFileLabels.resize(mDims.d[0], 0); mFileImgList = fileimglist; readInListFile(fileimglist, mListImg); mFileLabelList = filelabellist; @@ -27,7 +27,7 @@ BatchStream::BatchStream(tk::dnn::dataDim_t dim, int batchSize, int maxBatches, void BatchStream::reset(int firstBatch) { mBatchCount = 0; mFileCount = 0; - mFileBatchPos = mDims.n(); + mFileBatchPos = mDims.d[0]; skip(firstBatch); } @@ -37,11 +37,11 @@ bool BatchStream::next() { return false; for (int csize = 1, batchPos = 0; batchPos < mBatchSize; batchPos += csize, mFileBatchPos += csize) { - assert(mFileBatchPos > 0 && mFileBatchPos <= mDims.n()); - if (mFileBatchPos == mDims.n() && !update()) + assert(mFileBatchPos > 0 && mFileBatchPos <= mDims.d[0]); + if (mFileBatchPos == mDims.d[0] && !update()) return false; - csize = std::min(mBatchSize - batchPos, mDims.n() - mFileBatchPos); + csize = std::min(mBatchSize - batchPos, mDims.d[0] - mFileBatchPos); std::copy_n(getFileBatch() + mFileBatchPos * mImageSize, csize * mImageSize, getBatch() + batchPos * mImageSize); std::copy_n(getFileLabels() + mFileBatchPos, csize, getLabels() + batchPos); } @@ -50,8 +50,8 @@ bool BatchStream::next() { } void BatchStream::skip(int skipCount) { - if (mBatchSize >= mDims.n() && mBatchSize%mDims.n() == 0 && mFileBatchPos == mDims.n()) { - mFileCount += skipCount * mBatchSize / mDims.n(); + if (mBatchSize >= mDims.d[0] && mBatchSize%mDims.d[0] == 0 && mFileBatchPos == mDims.d[0]) { + mFileCount += skipCount * mBatchSize / mDims.d[0]; return; } diff --git a/src/Int8Calibrator.cpp b/src/Int8Calibrator.cpp index 773a9d8..691f847 100644 --- a/src/Int8Calibrator.cpp +++ b/src/Int8Calibrator.cpp @@ -8,13 +8,13 @@ Int8EntropyCalibrator::Int8EntropyCalibrator(BatchStream& stream, int firstBatch mCalibTableFilePath(calibTableFilePath), mInputBlobName(inputBlobName.c_str()), mReadCache(readCache) { - nvinfer1::DimsNCHW dims = mStream.getDims(); - mInputCount = mStream.getBatchSize() * dims.c() * dims.h() * dims.w(); + nvinfer1::Dims4 dims = mStream.getDims(); + mInputCount = mStream.getBatchSize() + dims.d[1]*dims.d[2]*dims.d[3]; checkCuda(cudaMalloc(&mDeviceInput, mInputCount * sizeof(float))); mStream.reset(firstBatch); } -bool Int8EntropyCalibrator::getBatch(void* bindings[], const char* names[], int nbBindings) { +bool Int8EntropyCalibrator::getBatch(void* bindings[], const char* names[], int nbBindings) NOEXCEPT { if (!mStream.next()) return false; @@ -24,7 +24,7 @@ bool Int8EntropyCalibrator::getBatch(void* bindings[], const char* names[], int return true; } -const void* Int8EntropyCalibrator::readCalibrationCache(size_t& length) { +const void* Int8EntropyCalibrator::readCalibrationCache(size_t& length) NOEXCEPT { mCalibrationCache.clear(); assert(!mCalibTableFilePath.empty()); std::ifstream input(mCalibTableFilePath, std::ios::binary); @@ -38,7 +38,7 @@ const void* Int8EntropyCalibrator::readCalibrationCache(size_t& length) { return length ? &mCalibrationCache[0] : nullptr; } -void Int8EntropyCalibrator::writeCalibrationCache(const void* cache, size_t length) { +void Int8EntropyCalibrator::writeCalibrationCache(const void* cache, size_t length) NOEXCEPT { assert(!mCalibTableFilePath.empty()); std::ofstream output(mCalibTableFilePath, std::ios::binary); output.write(reinterpret_cast(cache), length); diff --git a/src/MobilenetDetection.cpp b/src/MobilenetDetection.cpp index 13b836f..94c90c7 100644 --- a/src/MobilenetDetection.cpp +++ b/src/MobilenetDetection.cpp @@ -126,7 +126,7 @@ float MobilenetDetection::iou(const tk::dnn::box &a, const tk::dnn::box &b){ return iou; } -bool MobilenetDetection::init(const std::string& tensor_path, const int n_classes, const int n_batches, const float conf_thresh){ +bool MobilenetDetection::init(const std::string& tensor_path, const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches, const float conf_thresh){ std::cout<<(tensor_path).c_str()<<"\n"; netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str()); imageSize = netRT->input_dim.h; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 6ac7235..c7427d1 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -8,14 +8,16 @@ #include "utils.h" #include "NvInfer.h" + #include "NetworkRT.h" #include "Int8Calibrator.h" + using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { - void log(Severity severity, const char* msg) override { + void log(Severity severity, const char* msg) NOEXCEPT override { #ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; #endif @@ -24,28 +26,28 @@ class Logger : public ILogger { namespace tk { namespace dnn { -std::maptensors; +std::maptensors; NetworkRT::NetworkRT(Network *net, const char *name) { - float rt_ver = float(NV_TENSORRT_MAJOR) + - float(NV_TENSORRT_MINOR)/10 + + float rt_ver = float(NV_TENSORRT_MAJOR) + + float(NV_TENSORRT_MINOR)/10 + float(NV_TENSORRT_PATCH)/100; std::cout<<"New NetworkRT (TensorRT v"<platformHasFastFp16()<<"\n"; std::cout<<"Int8 support: "<platformHasFastInt8()<<"\n"; #if NV_TENSORRT_MAJOR >= 5 std::cout<<"DLAs: "<getNbDLACores()<<"\n"; #endif - networkRT = builderRT->createNetwork(); -#if NV_TENSORRT_MAJOR >= 6 + networkRT = builderRT->createNetworkV2(0U); +#if NV_TENSORRT_MAJOR >= 6 configRT = builderRT->createBuilderConfig(); #endif - + if(!fileExist(name)) { -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 // Calibrator life time needs to last until after the engine is built. std::unique_ptr calibrator; @@ -53,38 +55,37 @@ NetworkRT::NetworkRT(Network *net, const char *name) { configRT->setMinTimingIterations(1); configRT->setMaxWorkspaceSize(1 << 30); configRT->setFlag(BuilderFlag::kDEBUG); + #endif //input and dataType dataDim_t dim = net->layers[0]->input_dim; dtRT = DataType::kFLOAT; builderRT->setMaxBatchSize(net->maxBatchSize); - builderRT->setMaxWorkspaceSize(1 << 30); if(net->fp16 && builderRT->platformHasFastFp16()) { dtRT = DataType::kHALF; - builderRT->setHalf2Mode(true); -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 configRT->setFlag(BuilderFlag::kFP16); #endif } #if NV_TENSORRT_MAJOR >= 5 if(net->dla && builderRT->getNbDLACores() > 0) { dtRT = DataType::kHALF; - builderRT->setFp16Mode(true); - builderRT->allowGPUFallback(true); - builderRT->setDefaultDeviceType(DeviceType::kDLA); - builderRT->setDLACore(0); + configRT->setFlag(BuilderFlag::kFP16); + configRT->setFlag(BuilderFlag::kGPU_FALLBACK); + configRT->setDefaultDeviceType(DeviceType::kDLA); + configRT->setDLACore(0); } #endif -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 if(net->int8 && builderRT->platformHasFastInt8()){ // dtRT = DataType::kINT8; // builderRT->setInt8Mode(true); configRT->setFlag(BuilderFlag::kINT8); - BatchStream calibrationStream(dim, 1, 100, //TODO: check if 100 images are sufficient to the calibration (or 4951) + BatchStream calibrationStream(dim, 1, 100, //TODO: check if 100 images are sufficient to the calibration (or 4951) net->fileImgList, net->fileLabelList); - + /* The calibTableFilePath contains the path+filename of the calibration table. * Each calibration table can be found in the corresponding network folder (../Test/*). * Each network is located in a folder with the same name as the network. @@ -95,33 +96,33 @@ NetworkRT::NetworkRT(Network *net, const char *name) { if(!fileExist((const char *)calib_table_path.c_str())) calib_table_name = "./" + net->networkNameRT.substr(0, net->networkNameRT.find('.')) + "-calibration.table"; - calibrator.reset(new Int8EntropyCalibrator(calibrationStream, 1, - calib_table_name, + calibrator.reset(new Int8EntropyCalibrator(calibrationStream, 1, + calib_table_name, "data")); configRT->setInt8Calibrator(calibrator.get()); } #endif - + // add input layer - ITensor *input = networkRT->addInput("data", DataType::kFLOAT, - DimsCHW{ dim.c, dim.h, dim.w}); + ITensor *input = networkRT->addInput("data", DataType::kFLOAT, + Dims3{ dim.c, dim.h, dim.w}); checkNULL(input); //add other layers for(int i=0; inum_layers; i++) { Layer *l = net->layers[i]; ILayer *Ilay = convert_layer(input, l); -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 if(net->int8 && builderRT->platformHasFastInt8()) { Ilay->setPrecision(DataType::kINT8); } #endif Ilay->setName( (l->getLayerName() + std::to_string(i)).c_str() ); - + input = Ilay->getOutput(0); input->setName( (l->getLayerName() + std::to_string(i) + "_out").c_str() ); - + if(l->final) networkRT->markOutput(*input); tensors[l] = input; @@ -136,19 +137,38 @@ NetworkRT::NetworkRT(Network *net, const char *name) { std::cout<<"Selected maxBatchSize: "<getMaxBatchSize()<<"\n"; printCudaMemUsage(); std::cout<<"Building tensorRT cuda engine...\n"; -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 && NV_TENSORRT_MAJOR <=7 engineRT = builderRT->buildEngineWithConfig(*networkRT, *configRT); -#else +#elif NV_TENSORRT_MAJOR < 6 engineRT = builderRT->buildCudaEngine(*networkRT); //engineRT = std::shared_ptr(builderRT->buildCudaEngine(*networkRT)); +#elif NV_TENSORRT_MAJOR >=8 + IHostMemory *serializedEngineRT = builderRT->buildSerializedNetwork(*networkRT,*configRT); + #endif +#if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 if(engineRT == nullptr) FatalError("cloud not build cuda engine") // we don't need the network any more //networkRT->destroy(); std::cout<<"serialize net\n"; + builderActive = true; serialize(name); +#else + if(serializedEngineRT == nullptr){ + FatalError("could not build cuda engine"); + } + std::cout<<"saving serialized network to file"<= 8 + deserialize(name); +#endif + +#endif } else { + builderActive = false; deserialize(name); } @@ -162,7 +182,7 @@ NetworkRT::NetworkRT(Network *net, const char *name) { // In order to bind the buffers, we need to know the names of the input and output tensors. // note that indices are guaranteed to be less than IEngine::getNbBindings() - buf_input_idx = engineRT->getBindingIndex("data"); + buf_input_idx = engineRT->getBindingIndex("data"); buf_output_idx = engineRT->getBindingIndex("out"); std::cout<<"input index = "< output index = "<getNbLayers()<getNbLayers()<getNbBindings(); i++) { Dims dim = engineRT->getBindingDimensions(i); @@ -251,6 +275,10 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Layer *l) { return convert_layer(input, (Upsample*) l); if(type == LAYER_DEFORMCONV2D) return convert_layer(input, (DeformConv2d*) l); + if(type == LAYER_PADDING) + return convert_layer(input, (Padding*) l); + if(type == LAYER_MULADD) + return convert_layer(input,(MulAdd*) l); std::cout<getLayerName()<<"\n"; FatalError("Layer not implemented in tensorRT"); @@ -261,10 +289,10 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Dense *l) { //std::cout<<"convert Dense\n"; void *data_b, *bias_b; if(dtRT == DataType::kHALF) { - data_b = l->data16_h; + data_b = l->data16_h; bias_b = l->bias16_h; } else { - data_b = l->data_h; + data_b = l->data_h; bias_b = l->bias_h; } @@ -284,7 +312,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { void *data_b, *bias_b, *bias2_b, *power_b, *mean_b, *variance_b, *scales_b; if(dtRT == DataType::kHALF) { - data_b = l->data16_h; + data_b = l->data16_h; bias_b = l->bias16_h; bias2_b = l->bias216_h; power_b = l->power16_h; @@ -292,7 +320,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { variance_b = l->variance16_h; scales_b = l->scales16_h; } else { - data_b = l->data_h; + data_b = l->data_h; bias_b = l->bias_h; bias2_b = l->bias2_h; power_b = l->power_h; @@ -308,14 +336,15 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { b = { dtRT, bias_b, l->outputs}; else{ if (l->additional_bias) - b = { dtRT, bias2_b, l->outputs}; + b = { dtRT, bias2_b, l->outputs}; else b = { dtRT, nullptr, 0}; //on batchnorm bias are added later } ILayer *lRT = nullptr; +#if NV_TENSORRT_MAJOR < 8 if(!l->deConv) { - IConvolutionLayer *lRTconv = networkRT->addConvolution(*input, + IConvolutionLayer *lRTconv = networkRT->addConvolution(*input, l->outputs, DimsHW{l->kernelH, l->kernelW}, w, b); checkNULL(lRTconv); lRTconv->setStride(DimsHW{l->strideH, l->strideW}); @@ -323,17 +352,39 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { lRTconv->setNbGroups(l->groups); lRT = (ILayer*) lRTconv; } else { - IDeconvolutionLayer *lRTconv = networkRT->addDeconvolution(*input, + IDeconvolutionLayer *lRTconv = networkRT->addDeconvolution(*input, l->outputs, DimsHW{l->kernelH, l->kernelW}, w, b); checkNULL(lRTconv); lRTconv->setStride(DimsHW{l->strideH, l->strideW}); lRTconv->setPadding(DimsHW{l->paddingH, l->paddingW}); lRTconv->setNbGroups(l->groups); lRT = (ILayer*) lRTconv; - + Dims d = lRTconv->getOutput(0)->getDimensions(); //std::cout<<"DECONV: "<deConv) { + IConvolutionLayer *lRTconv = networkRT->addConvolutionNd(*input, + l->outputs, Dims2{l->kernelH, l->kernelW}, w, b); + checkNULL(lRTconv); + lRTconv->setStrideNd(Dims2{l->strideH, l->strideW}); + lRTconv->setPaddingNd(Dims2{l->paddingH, l->paddingW}); + lRTconv->setNbGroups(l->groups); + lRT = (ILayer*) lRTconv; + } else { + IDeconvolutionLayer *lRTconv = networkRT->addDeconvolutionNd(*input, + l->outputs, Dims2{l->kernelH, l->kernelW}, w, b); + checkNULL(lRTconv); + lRTconv->setStrideNd(Dims2{l->strideH, l->strideW}); + lRTconv->setPaddingNd(Dims2{l->paddingH, l->paddingW}); + lRTconv->setNbGroups(l->groups); + lRT = (ILayer*) lRTconv; + + Dims d = lRTconv->getOutput(0)->getDimensions(); + //std::cout<<"DECONV: "<batchnorm) { @@ -341,14 +392,14 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { Weights shift{dtRT, mean_b, l->outputs}; Weights scale{dtRT, variance_b, l->outputs}; // std::cout<getNbOutputs()<addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT2 = networkRT->addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, shift, scale, power); - + checkNULL(lRT2); Weights shift2{dtRT, bias_b, l->outputs}; Weights scale2{dtRT, scales_b, l->outputs}; - IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, shift2, scale2, power); checkNULL(lRT3); @@ -358,6 +409,80 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { return lRT; } +ILayer* NetworkRT::convert_layer(ITensor *input,MulAdd *l){ + + void *power_b, *shift_b, *scales_b; + int size = l->input_dim.tot(); + + power_b = new dnnType[size]; + shift_b = new dnnType[size]; + scales_b = new dnnType[size]; + + for(int i=0; iadd; + ((dnnType*) scales_b)[i] = l->mul; + } + + if(dtRT == DataType::kHALF) { + + __half *power16_h = nullptr, *power16_d = nullptr; + __half *scales16_h = nullptr, *scales16_d = nullptr; + __half *shift16_h = nullptr, *shift16_d = nullptr; + + dnnType * power_d = nullptr; + dnnType * scales_d = nullptr; + dnnType * shift_d = nullptr; + + cudaMalloc(&power_d, size*sizeof(dnnType)); + cudaMemcpy(power_d, power_b, size*sizeof(dnnType), cudaMemcpyHostToDevice); + + cudaMalloc(&shift_d, size*sizeof(dnnType)); + cudaMemcpy(shift_d, shift_b, size*sizeof(dnnType), cudaMemcpyHostToDevice); + + cudaMalloc(&scales_d, size*sizeof(dnnType)); + cudaMemcpy(scales_d, scales_b, size*sizeof(dnnType), cudaMemcpyHostToDevice); + + //convert to fp16 + power16_h = new __half[size]; + cudaMalloc(&power16_d, size*sizeof(__half)); + float2half(power_d, power16_d, size); + cudaMemcpy(power16_h, power16_d, size*sizeof(__half), cudaMemcpyDeviceToHost); + + shift16_h = new __half[size]; + cudaMalloc(&shift16_d, size*sizeof(__half)); + float2half(shift_d, shift16_d, size); + cudaMemcpy(shift16_h, shift16_d, size*sizeof(__half), cudaMemcpyDeviceToHost); + + scales16_h = new __half[size]; + cudaMalloc(&scales16_d, size*sizeof(__half)); + float2half(scales_d, scales16_d, size); + cudaMemcpy(scales16_h, scales16_d, size*sizeof(__half), cudaMemcpyDeviceToHost); + + power_b = power16_h; + shift_b = shift16_h; + scales_b = scales16_h; + + + cudaFree(power16_d); + cudaFree(shift16_d); + cudaFree(scales16_d); + + cudaFree(power_d); + cudaFree(shift_d); + cudaFree(scales_d); + } + + Weights power{dtRT, power_b, size}; + Weights shift{dtRT, shift_b, size}; + Weights scale{dtRT, scales_b, size}; + IScaleLayer *lRT = networkRT->addScale(*input, ScaleMode::kELEMENTWISE, + shift, scale, power); + checkNULL(lRT); + return lRT; +} + + ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { // std::cout<<"convert Pooling\n"; @@ -368,20 +493,103 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { if(l->pool_mode == tkdnnPoolingMode_t::POOLING_MAX_FIXEDSIZE) { - IPlugin *plugin = new MaxPoolFixedSizeRT(l->output_dim.c, l->output_dim.h, l->output_dim.w, l->output_dim.n, l->strideH, l->strideW, l->winH, l->winH-1); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("MaxPoolingFixedSizeRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("c",&l->output_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->output_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("strideH",&l->strideH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("strideW",&l->strideW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("winSize",&l->winH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padding",&l->padding,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; + } else { +#if NV_TENSORRT_MAJOR < 8 IPoolingLayer *lRT = networkRT->addPooling(*input, ptype, DimsHW{l->winH, l->winW}); checkNULL(lRT); lRT->setPadding(DimsHW{l->paddingH, l->paddingW}); lRT->setStride(DimsHW{l->strideH, l->strideW}); return lRT; - } +#else + IPoolingLayer *lRT = networkRT->addPoolingNd(*input,ptype,Dims2{l->winH,l->winW}); + checkNULL(lRT); + lRT->setPaddingNd(Dims2{l->paddingH,l->paddingW}); + lRT->setStrideNd(Dims2{l->strideH,l->strideW}); + return lRT; +#endif + } +} + +ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ + + float rt_ver = float(NV_TENSORRT_MAJOR) + + float(NV_TENSORRT_MINOR)/10 + + float(NV_TENSORRT_PATCH)/100; + +/*#if ((NV_TENSORRT_MAJOR == 8 && NV_TENSORRT_MINOR >= 2) || NV_TENSORRT_MAJOR > 8) + auto *lRT = networkRT->addSlice(*input,Dims3{0,0,0},Dims3{l->output_dim.c,l->output_dim.h,l->output_dim.w},Dims3{0,0,0}); + if(l->padding_mode == PADDING_MODE_REFLECTION){ + lRT->setMode(SliceMode::kREFLECT); + }else if(l->padding_mode == PADDING_MODE_CONSTANT || l->padding_mode == PADDING_MODE_ZERO){ + lRT->setMode(SliceMode::kFILL); + lRT->setInput(4, reinterpret_cast(l->constant)); + } + checkNULL(lRT); + return lRT; +#else*/ + //todo use ISliceLayer for padding,currently using ISliceLayer for reflection padding generates an error with monodepth2 + if(l->padding_mode == PADDING_MODE_REFLECTION){ + auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); + checkNULL(lRT); + return lRT; + }else if(l->padding_mode == PADDING_MODE_CONSTANT || l->padding_mode == PADDING_MODE_ZERO){ + auto creator = getPluginRegistry()->getPluginCreator("ConstantPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("constant",&l->constant,PluginFieldType::kFLOAT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input,1,*plugin); + checkNULL(lRT); + return lRT; + } + + return nullptr; + } ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { @@ -389,14 +597,14 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { if(l->act_mode == ACTIVATION_LEAKY) { //std::cout<<"New plugin LEAKY\n"; - -#if NV_TENSORRT_MAJOR < 6 + +#if NV_TENSORRT_MAJOR < 6 // plugin version IPlugin *plugin = new ActivationLeakyRT(l->slope); IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); checkNULL(lRT); return lRT; -#else +#else IActivationLayer *lRT = networkRT->addActivation(*input, ActivationType::kLEAKY_RELU); lRT->setAlpha(l->slope); checkNULL(lRT); @@ -413,20 +621,30 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { return lRT; } else if(l->act_mode == CUDNN_ACTIVATION_CLIPPED_RELU) { - IPlugin *plugin = new ActivationReLUCeiling(l->ceiling); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kCLIP); + //IPluginV2 *plugin = new ActivationReLUCeiling(l->ceiling); + lRT->setAlpha(0); + lRT->setBeta(l->ceiling); checkNULL(lRT); + //IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + //checkNULL(lRT); return lRT; - } + } else if(l->act_mode == ACTIVATION_MISH) { - IPlugin *plugin = new ActivationMishRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IActivationLayer *lRT1 = networkRT->addActivation(*input, ActivationType::kSOFTPLUS); + lRT1->setAlpha(1); + lRT1->setBeta(1); + IActivationLayer *lRT2 = networkRT->addActivation(*lRT1->getOutput(0), ActivationType::kTANH); + IElementWiseLayer *lRT3 = networkRT->addElementWise(*input, *lRT2->getOutput(0), ElementWiseOperation::kPROD); + return lRT3; + } + else if(l->act_mode == ACTIVATION_LOGISTIC) { + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kSIGMOID); checkNULL(lRT); return lRT; } - else if(l->act_mode == ACTIVATION_LOGISTIC) { - IPlugin *plugin = new ActivationLogisticRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + else if(l->act_mode == CUDNN_ACTIVATION_ELU || l->act_mode == ACTIVATION_ELU){ + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kELU); checkNULL(lRT); return lRT; } @@ -447,7 +665,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Softmax *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { // std::cout<<"convert route\n"; - + ITensor **tens = new ITensor*[l->layers_n]; @@ -460,8 +678,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { } if(l->groups > 1){ - IPlugin *plugin = new RouteRT(l->groups, l->group_id); - IPluginLayer *lRT = networkRT->addPlugin(tens, l->layers_n, *plugin); + IPluginV2 *plugin = new RouteRT(l->groups, l->group_id); + IPluginV2Layer *lRT = networkRT->addPluginV2(tens, l->layers_n, *plugin); checkNULL(lRT); return lRT; } @@ -470,19 +688,36 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { - - IPlugin *plugin = new FlattenConcatRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { + auto creator = getPluginRegistry()->getPluginCreator("FlattenConcatRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("rows",&l->rows,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("cols",&l->cols,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Reshape *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Reshape *l) { // std::cout<<"convert Reshape\n"; - - IPlugin *plugin = new ReshapeRT(l->output_dim); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("ReshapeRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("n",&l->n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -494,26 +729,46 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Resize *l) { checkNULL(lRT); Dims d{}; lRT->setResizeMode(ResizeMode(l->mode)); - lRT->setOutputDimensions(DimsCHW{l->output_dim.c, l->output_dim.h, l->output_dim.w}); + lRT->setOutputDimensions(Dims3{l->output_dim.c, l->output_dim.h, l->output_dim.w}); return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { //std::cout<<"convert Reorg\n"; //std::cout<<"New plugin REORG\n"; - IPlugin *plugin = new ReorgRT(l->stride); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("ReorgRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("stride",&l->stride,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Region *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Region *l) { //std::cout<<"convert Region\n"; //std::cout<<"New plugin REGION\n"; - IPlugin *plugin = new RegionRT(l->classes, l->coords, l->num); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("RegionRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("classes",&l->classes,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords",&l->coords,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("nums",&l->num,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -522,10 +777,10 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { //std::cout<<"convert Shortcut\n"; //std::cout<<"New plugin Shortcut\n"; - + ITensor *back_tens = tensors[l->backLayer]; - if(l->backLayer->output_dim.c == l->output_dim.c && !l->mul) + if(l->backLayer->output_dim.c == l->output_dim.c && !l->mul) { IElementWiseLayer *lRT = networkRT->addElementWise(*input, *back_tens, ElementWiseOperation::kSUM); checkNULL(lRT); @@ -534,34 +789,74 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { else { // plugin version - IPlugin *plugin = new ShortcutRT(l->backLayer->output_dim, l->mul); - ITensor **inputs = new ITensor*[2]; + auto creator = getPluginRegistry()->getPluginCreator("ShortcutRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("bc",&l->backLayer->output_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bh",&l->backLayer->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bw",&l->backLayer->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mul",&l->mul,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto **inputs = new ITensor*[2]; inputs[0] = input; - inputs[1] = back_tens; - IPluginLayer *lRT = networkRT->addPlugin(inputs, 2, *plugin); + inputs[1] = back_tens; + auto *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); return lRT; } } -ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { - //std::cout<<"convert Yolo\n"; +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { - //std::cout<<"New plugin YOLO\n"; - IPlugin *plugin = new YoloRT(l->classes, l->num, l, l->n_masks, l->scaleXY, l->nms_thresh, l->nsm_kind, l->new_coords); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("YoloRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("classes",&l->classes,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",&l->num,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n_masks",&l->n_masks,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scale_xy",&l->scaleXY,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_thresh",&l->nms_thresh,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_kins",&l->nsm_kind,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("new_coords",&l->new_coords,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { - //std::cout<<"convert Upsample\n"; - //std::cout<<"New plugin UPSAMPLE\n"; - IPlugin *plugin = new UpsampleRT(l->stride); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); +#if NV_TENSORRT_MAJOR < 8 + auto creator = getPluginRegistry()->getPluginCreator("UpSample_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("stride",&l->stride,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; +#else + auto *lRT = networkRT->addResize(*input); + lRT->setResizeMode(ResizeMode::kNEAREST); + lRT->setOutputDimensions(Dims3{l->output_dim.c, l->output_dim.h, l->output_dim.w}); + checkNULL(lRT); + return lRT; +#endif } ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { @@ -574,10 +869,53 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { inputs[1] = preconv->getOutput(0); //std::cout<<"New plugin DEFORMABLE\n"; - IPlugin *plugin = new DeformableConvRT(l->chunk_dim, l->kernelH, l->kernelW, l->strideH, l->strideW, l->paddingH, l->paddingW, - l->deformableGroup, l->input_dim.n, l->input_dim.c, l->input_dim.h, l->input_dim.w, - l->output_dim.n, l->output_dim.c, l->output_dim.h, l->output_dim.w, l); - IPluginLayer *lRT = networkRT->addPlugin(inputs, 2, *plugin); + int height_ones = (l->input_dim.h + 2 * l->paddingH - (1 * (l->kernelH - 1) + 1)) / l->strideH + 1; + int width_ones = (l->input_dim.w + 2 * l->paddingW - (1 * (l->kernelW - 1) + 1)) / l->strideW + 1; + int dim_ones = l->input_dim.c * l->kernelH * l->kernelW * 1 * height_ones * width_ones; + std::vector offsetV(2*l->chunk_dim); + std::vector maskV(l->chunk_dim); + std::vector dataV(l->input_dim.c*l->output_dim.c*l->kernelW*l->kernelH*1); + std::vector bias2DV(l->output_dim.c); + std::vector onesD1V(height_ones*width_ones); + std::vector onesD2V(dim_ones); + checkCuda(cudaMemcpy(offsetV.data(),l->offset,offsetV.size()*sizeof(dnnType),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(maskV.data(),l->mask,sizeof(dnnType)*maskV.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(dataV.data(),l->data_d,sizeof(dnnType)*dataV.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(bias2DV.data(),l->bias2_d,sizeof(dnnType)*bias2DV.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(onesD1V.data(),l->ones_d1,sizeof(dnnType)*onesD1V.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(onesD2V.data(),l->ones_d2,sizeof(dnnType)*onesD2V.size(),cudaMemcpyDeviceToHost)); + auto creator = getPluginRegistry()->getPluginCreator("DeformableConvRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("chunk_dum",&l->chunk_dim,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh",&l->kernelH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw",&l->kernelW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh",&l->strideH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw",&l->strideW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformable_group",&l->deformableGroup,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n",&l->output_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c",&l->output_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mask_v",&maskV[0],PluginFieldType::kFLOAT32,maskV.size())); + mPluginAttributes.emplace_back(PluginField("offset_v",&offsetV[0],PluginFieldType::kFLOAT32,offsetV.size())); + mPluginAttributes.emplace_back(PluginField("ones_d2_v",&onesD2V[0],PluginFieldType::kFLOAT32,onesD2V.size())); + mPluginAttributes.emplace_back(PluginField("ones_d1_v",&onesD1V[0],PluginFieldType::kFLOAT32,onesD1V.size())); + mPluginAttributes.emplace_back(PluginField("data_d_v",&dataV[0],PluginFieldType::kFLOAT32,dataV.size())); + mPluginAttributes.emplace_back(PluginField("bias2_d_v",&bias2DV[0],PluginFieldType::kFLOAT32,bias2DV.size())); + mPluginAttributes.emplace_back(PluginField("height_ones",&height_ones,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("width_ones",&width_ones,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("dim_ones",&dim_ones,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); lRT->setName( ("Deformable" + std::to_string(l->id)).c_str() ); delete[](inputs); @@ -601,20 +939,21 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { Weights shift{dtRT, mean_b, l->outputs}; Weights scale{dtRT, variance_b, l->outputs}; //std::cout<getNbOutputs()<addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT2 = networkRT->addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, shift, scale, power); - + checkNULL(lRT2); Weights shift2{dtRT, bias_b, l->outputs}; Weights scale2{dtRT, scales_b, l->outputs}; - IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, shift2, scale2, power); checkNULL(lRT3); return lRT3; } +#if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 bool NetworkRT::serialize(const char *filename) { std::ofstream p(filename, std::ios::binary); @@ -631,6 +970,21 @@ bool NetworkRT::serialize(const char *filename) { ptr->destroy(); return true; } +#else +bool NetworkRT::serialize(const char *filename,nvinfer1::IHostMemory *ptr){ + std::ofstream p(filename, std::ios::binary); + if (!p) { + FatalError("could not open plan output file"); + return false; + } + + if(ptr == nullptr) + FatalError("Cant serialize network"); + + p.write(reinterpret_cast(ptr->data()), ptr->size()); + return true; +} +#endif bool NetworkRT::deserialize(const char *filename) { @@ -646,256 +1000,27 @@ bool NetworkRT::deserialize(const char *filename) { file.close(); } - pluginFactory = new PluginFactory(); runtimeRT = createInferRuntime(loggerRT); - engineRT = runtimeRT->deserializeCudaEngine(gieModelStream, size, (IPluginFactory *) pluginFactory); + engineRT = runtimeRT->deserializeCudaEngine(gieModelStream, size); + std::cout<(serialData),*bufCheck = buf; - - std::string name(layerName); - //std::cout<(buf)); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; +#if NV_TENSORRT_MAJOR > 7 +void NetworkRT::destroy() { + delete contextRT; + if(builderActive) { + delete engineRT; + delete builderRT; } - if(name.find("ActivationMish") == 0) { - ActivationMishRT *a = new ActivationMishRT(); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; - } - if(name.find("ActivationLogistic") == 0) { - ActivationLogisticRT *a = new ActivationLogisticRT(); - a->size = readBUF(buf); - return a; - } - if(name.find("ActivationLogistic") == 0) { - ActivationLogisticRT *a = new ActivationLogisticRT(); - a->size = readBUF(buf); - return a; - } - if(name.find("ActivationCReLU") == 0) { - float activationReluTemp = readBUF(buf); - ActivationReLUCeiling* a = new ActivationReLUCeiling(activationReluTemp); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; - } - - if(name.find("Region") == 0) { - int classesTemp = readBUF(buf); - int coordsTemp = readBUF(buf); - int numTemp = readBUF(buf); - RegionRT* r = new RegionRT(classesTemp, coordsTemp, numTemp); - - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Reorg") == 0) { - int strideTemp = readBUF(buf); - ReorgRT *r = new ReorgRT(strideTemp); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Shortcut") == 0) { - tk::dnn::dataDim_t bdim; - bdim.c = readBUF(buf); - bdim.h = readBUF(buf); - bdim.w = readBUF(buf); - bdim.l = 1; - - ShortcutRT *r = new ShortcutRT(bdim, readBUF(buf)); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - return r; - assert(buf == bufCheck + serialLength); - } - - if(name.find("Pooling") == 0) { - int cTemp = readBUF(buf); - int hTemp = readBUF(buf); - int wTemp = readBUF(buf); - int nTemp = readBUF(buf); - int strideHTemp = readBUF(buf); - int strideWTemp = readBUF(buf); - int winSizeTemp = readBUF(buf); - int paddingTemp = readBUF(buf); - - MaxPoolFixedSizeRT* r = new MaxPoolFixedSizeRT(cTemp, hTemp, wTemp, nTemp, strideHTemp, strideWTemp, winSizeTemp, paddingTemp); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Resize") == 0) { - int o_cTemp = readBUF(buf); - int o_hTemp = readBUF(buf); - int o_wTemp = readBUF(buf); - ResizeLayerRT* r = new ResizeLayerRT(o_cTemp, o_hTemp, o_wTemp); - - r->i_c = readBUF(buf); - r->i_h = readBUF(buf); - r->i_w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Flatten") == 0) { - FlattenConcatRT *r = new FlattenConcatRT(); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - r->rows = readBUF(buf); - r->cols = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Reshape") == 0) { - - dataDim_t new_dim; - new_dim.n = readBUF(buf); - new_dim.c = readBUF(buf); - new_dim.h = readBUF(buf); - new_dim.w = readBUF(buf); - ReshapeRT *r = new ReshapeRT(new_dim); - assert(buf == bufCheck + serialLength); - - return r; - } - - if(name.find("Yolo") == 0) { - - int classes_temp = readBUF(buf); - int num_temp = readBUF(buf); - int n_masks_temp = readBUF(buf); - float scale_xy_temp = readBUF(buf); - float nms_thresh_temp = readBUF(buf); - int nms_kind_temp = readBUF(buf); - int new_coords_temp = readBUF(buf); - - YoloRT *r = new YoloRT(classes_temp,num_temp,nullptr,n_masks_temp,scale_xy_temp,nms_thresh_temp,nms_kind_temp,new_coords_temp); - - - - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - for(int i=0; in_masks; i++) - r->mask[i] = readBUF(buf); - for(int i=0; in_masks*2*r->num; i++) - r->bias[i] = readBUF(buf); - - // save classes names - r->classesNames.resize(r->classes); - for(int i=0; iclasses; i++) { - char tmp[YOLORT_CLASSNAME_W]; - for(int j=0; j(buf); - r->classesNames[i] = std::string(tmp); - } - assert(buf == bufCheck + serialLength); - - yolos[n_yolos++] = r; - return r; - } - if(name.find("Upsample") == 0) { - int strideTemp = readBUF(buf); - UpsampleRT* r = new UpsampleRT(strideTemp); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Route") == 0) { - int groupsTemp = readBUF(buf); - int group_idTemp = readBUF(buf); - RouteRT* r = new RouteRT(groupsTemp, group_idTemp); - r->in = readBUF(buf); - for(int i=0; ic_in[i] = readBUF(buf); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Deformable") == 0) { - int chuck_dimTemp = readBUF(buf); - int khTemp = readBUF(buf); - int kwTemp = readBUF(buf); - int shTemp = readBUF(buf); - int swTemp = readBUF(buf); - int phTemp = readBUF(buf); - int pwTemp = readBUF(buf); - int deformableGroupTemp = readBUF(buf); - int i_nTemp = readBUF(buf); - int i_cTemp = readBUF(buf); - int i_hTemp = readBUF(buf); - int i_wTemp = readBUF(buf); - int o_nTemp = readBUF(buf); - int o_cTemp = readBUF(buf); - int o_hTemp = readBUF(buf); - int o_wTemp = readBUF(buf); - - DeformableConvRT* r = new DeformableConvRT(chuck_dimTemp, khTemp, kwTemp, shTemp, swTemp, phTemp, pwTemp, deformableGroupTemp, i_nTemp, i_cTemp, i_hTemp, i_wTemp, o_nTemp, o_cTemp, o_hTemp, o_wTemp, nullptr); - dnnType *aus = new dnnType[r->chunk_dim*2]; - for(int i=0; ichunk_dim*2; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->offset, aus, sizeof(dnnType)*2*r->chunk_dim, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->chunk_dim]; - for(int i=0; ichunk_dim; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->mask, aus, sizeof(dnnType)*r->chunk_dim, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[(r->i_c * r->o_c * r->kh * r->kw * 1 )]; - for(int i=0; i<(r->i_c * r->o_c * r->kh * r->kw * 1 ); i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->data_d, aus, sizeof(dnnType)*(r->i_c * r->o_c * r->kh * r->kw * 1 ), cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->o_c]; - for(int i=0; i < r->o_c; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->bias2_d, aus, sizeof(dnnType)*r->o_c, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->height_ones * r->width_ones]; - for(int i=0; iheight_ones * r->width_ones; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->ones_d1, aus, sizeof(dnnType)*r->height_ones * r->width_ones, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->dim_ones]; - for(int i=0; idim_ones; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->ones_d2, aus, sizeof(dnnType)*r->dim_ones, cudaMemcpyHostToDevice) ); - free(aus); - assert(buf == bufCheck + serialLength); - return r; - } - - FatalError("Cant deserialize Plugin"); - return NULL; } +#elif NV_TENSORRT_MAJOR <=7 +void NetworkRT::destroy() { + +} +#endif + }} diff --git a/src/NetworkViz.cpp b/src/NetworkViz.cpp index b6c95d9..8dbb20e 100644 --- a/src/NetworkViz.cpp +++ b/src/NetworkViz.cpp @@ -383,7 +383,7 @@ cv::Mat vizFloat2colorMap(cv::Mat map,double min, double max, int classes) { default: // expand your range to 0..255. Similar to histEq(); map.convertTo(adjMap,CV_8UC1, 255 / (max-min), -min); - applyColorMap(adjMap, falseColorsMap, cv::COLORMAP_JET); + applyColorMap(adjMap, falseColorsMap, cv::COLORMAP_PARULA); } return falseColorsMap; } diff --git a/src/Padding.cpp b/src/Padding.cpp new file mode 100644 index 0000000..1ba6d38 --- /dev/null +++ b/src/Padding.cpp @@ -0,0 +1,45 @@ +// +// Created by perseusdg on 03/01/22. +// + +#include +#include "Layer.h" +#include "kernels.h" + +namespace tk{ namespace dnn { + Padding::Padding(Network *net, int32_t pad_h, int32_t pad_w, tkdnnPaddingMode_t padding_mode,float constant) : Layer(net) { + this->paddingH = pad_h; + this->paddingW = pad_w; + this->padding_mode = padding_mode; + output_dim.c = input_dim.c; + output_dim.n = input_dim.n; + output_dim.h = input_dim.h + 2 * (this->paddingH); + output_dim.w = input_dim.w + 2 * (this->paddingW); + if(padding_mode == tkdnnPaddingMode_t::PADDING_MODE_CONSTANT){ + this->constant = constant; + }else{ + this->constant = 0; + } + checkCuda(cudaMalloc(&dstData,output_dim.tot()*sizeof(dnnType))); + } + + Padding::~Padding() { + checkCuda(cudaFree(dstData)); + } + dnnType* Padding::infer(dataDim_t &dim, float *srcData) { + fill(dstData,output_dim.tot(),0.0); + if(padding_mode == tkdnnPaddingMode_t::PADDING_MODE_REFLECTION) + { + reflection_pad2d_out_forward(paddingH, paddingW, srcData, dstData, input_dim.h, input_dim.w, input_dim.c, + input_dim.n); + } + else if(padding_mode == tkdnnPaddingMode_t::PADDING_MODE_CONSTANT){ + constant_pad2d_forward(srcData,dstData,input_dim.h,input_dim.w,output_dim.h,output_dim.w,input_dim.c, + input_dim.n,paddingH,paddingW,constant); + } + + dim = output_dim; + return dstData; + } + +}} diff --git a/src/Pooling.cpp b/src/Pooling.cpp index 0838806..2cea2f6 100644 --- a/src/Pooling.cpp +++ b/src/Pooling.cpp @@ -17,6 +17,7 @@ Pooling::Pooling( Network *net, int winH, int winW, int strideH, int strideW, this->pool_mode = pool_mode; this->paddingH = paddingH; this->paddingW = paddingW; + this->padding = winH -1; checkCUDNN( cudnnCreatePoolingDescriptor(&poolingDesc) ); diff --git a/src/Region.cpp b/src/Region.cpp index 7c26208..46e0cff 100644 --- a/src/Region.cpp +++ b/src/Region.cpp @@ -16,7 +16,6 @@ Region::Region(Network *net, int classes, int coords, int num) : this->classes = classes; this->coords = coords; this->num = num; - // same output_dim.n = input_dim.n; output_dim.c = input_dim.c; diff --git a/src/Reshape.cpp b/src/Reshape.cpp index f43c4ee..f966b27 100644 --- a/src/Reshape.cpp +++ b/src/Reshape.cpp @@ -8,7 +8,10 @@ namespace tk { namespace dnn { Reshape::Reshape(Network *net, dataDim_t new_dim) : Layer(net) { checkCuda( cudaMalloc(&dstData, input_dim.tot()*sizeof(dnnType)) ); - + this->n = new_dim.n; + this->c = new_dim.c; + this->h = new_dim.h; + this->w = new_dim.w; output_dim.n = new_dim.n; output_dim.c = new_dim.c; output_dim.h = new_dim.h; diff --git a/src/Shortcut.cpp b/src/Shortcut.cpp index b1053c8..0488487 100644 --- a/src/Shortcut.cpp +++ b/src/Shortcut.cpp @@ -9,6 +9,9 @@ Shortcut::Shortcut(Network *net, Layer *backLayer, bool mul) : Layer(net) { this->backLayer = backLayer; this->mul = mul; + this->c = input_dim.c; + this->h = input_dim.h; + this->w = input_dim.w; checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); if( ( backLayer->output_dim.c != input_dim.c && mul ) || diff --git a/src/Upsample.cpp b/src/Upsample.cpp index 943cb2b..4f35d0f 100644 --- a/src/Upsample.cpp +++ b/src/Upsample.cpp @@ -14,6 +14,9 @@ Upsample::Upsample(Network *net, int stride) : Layer(net) { output_dim.h = input_dim.h*stride; output_dim.w = input_dim.w*stride; output_dim.l = input_dim.l; + this->c = input_dim.c; + this->h = input_dim.h; + this->w = input_dim.w; checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); } diff --git a/src/Yolo.cpp b/src/Yolo.cpp index db14774..b68e1f6 100644 --- a/src/Yolo.cpp +++ b/src/Yolo.cpp @@ -133,7 +133,7 @@ void correct_yolo_boxes(Yolo::detection *dets, int n, int w, int h, int netw, in } } -int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int neth, float thresh, int new_coords) { +int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int neth, float thresh, int newCoords) { if(predictions == nullptr) predictions = new dnnType[output_dim.tot()]; @@ -157,7 +157,7 @@ int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int net if(objectness <= thresh) continue; int box_index = entry_index(0, n*lw*lh + i, 0, classes, input_dim, output_dim); - dets[count].bbox = get_yolo_box(predictions, bias_h, mask_h[n], box_index, col, row, lw, lh, netw, neth, lw*lh, new_coords); + dets[count].bbox = get_yolo_box(predictions, bias_h, mask_h[n], box_index, col, row, lw, lh, netw, neth, lw*lh, newCoords); dets[count].objectness = objectness; dets[count].classes = classes; for(j = 0; j < classes; ++j){ diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 0c638e6..bda206a 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -3,38 +3,54 @@ namespace tk { namespace dnn { -bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, const int n_batches, const float conf_thresh) { + bool Yolo3Detection::init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches, const float conf_thresh) { //convert network to tensorRT std::cout<<(tensor_path).c_str()<<"\n"; - netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() ); + netRT = new tk::dnn::NetworkRT(nullptr, (tensor_path).c_str() ); nBatches = n_batches; confThreshold = conf_thresh; tk::dnn::dataDim_t idim = netRT->input_dim; idim.n = nBatches; - if(netRT->pluginFactory->n_yolos < 2 ) { + std::vector yolosLine = noYolosLine(cfg_path); + noYolos = yolosLine; + int channels,height,width; + loadYoloInitInfo(channels,width,height,cfg_path); + + + + if(yolosLine.size() < 2 ) { FatalError("this is not yolo3"); } - for(int i=0; ipluginFactory->n_yolos; i++) { - YoloRT *yRT = netRT->pluginFactory->yolos[i]; - classes = yRT->classes; - num = yRT->num; - nMasks = yRT->n_masks; + for(int i=0; i maskTemp,anchorsTemp; + std::vector classNamesTemp; + int nms_kind,coords,numTemp; + float nmsthresh; + loadYoloInfo(cfg_path,yolosLine[i],maskTemp,anchorsTemp,numTemp,classes,nmsthresh,nms_kind,coords); + classNamesTemp = darknetReadNames(name_path); + num = numTemp/maskTemp.size(); + nMasks = maskTemp.size(); + dnnType* maskTempF; + dnnType* biasTempF; + maskTempF = maskTemp.data(); + biasTempF = anchorsTemp.data(); // make a yolo layer to interpret predictions yolo[i] = new tk::dnn::Yolo(nullptr, classes, nMasks, ""); // yolo without input and bias yolo[i]->mask_h = new dnnType[nMasks]; yolo[i]->bias_h = new dnnType[num*nMasks*2]; - memcpy(yolo[i]->mask_h, yRT->mask, sizeof(dnnType)*nMasks); - memcpy(yolo[i]->bias_h, yRT->bias, sizeof(dnnType)*num*nMasks*2); - yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, yRT->c, yRT->h, yRT->w); - yolo[i]->classesNames = yRT->classesNames; - yolo[i]->nms_thresh = yRT->nms_thresh; - yolo[i]->nsm_kind = (tk::dnn::Yolo::nmsKind_t) yRT->nms_kind; - yolo[i]->new_coords = yRT->new_coords; + memcpy(yolo[i]->mask_h, maskTempF, sizeof(dnnType)*nMasks); + memcpy(yolo[i]->bias_h, biasTempF, sizeof(dnnType)*num*nMasks*2); + auto dim = netRT->engineRT->getBindingDimensions(i+1); + yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, dim.d[0], dim.d[1], dim.d[2]); + yolo[i]->classesNames = classNamesTemp; + yolo[i]->nms_thresh = nmsthresh; + yolo[i]->nsm_kind = (tk::dnn::Yolo::nmsKind_t) nms_kind; + yolo[i]->new_coords = coords; } dets = tk::dnn::Yolo::allocateDetections(tk::dnn::Yolo::MAX_DETECTIONS, classes); @@ -93,10 +109,15 @@ void Yolo3Detection::preprocess(cv::Mat &frame, const int bi){ void Yolo3Detection::postprocess(const int bi, const bool mAP){ + + //get yolo outputs + if(noYolos.size() < 2){ + FatalError("YOLOS WRONG!!"); + } std::vector rt_out; //dnnType *rt_out[netRT->pluginFactory->n_yolos]; - for(int i=0; ipluginFactory->n_yolos; i++) + for(int i=0; ibuffersRT[i+1] + netRT->buffersDIM[i+1].tot()*bi); float x_ratio = float(originalSize[bi].width) / float(netRT->input_dim.w); @@ -104,7 +125,7 @@ void Yolo3Detection::postprocess(const int bi, const bool mAP){ // compute dets nDets = 0; - for(int i=0; ipluginFactory->n_yolos; i++) { + for(int i=0; idstData = rt_out[i]; yolo[i]->computeDetections(dets, nDets, netRT->input_dim.w, netRT->input_dim.h, confThreshold, yolo[i]->new_coords); } diff --git a/src/kernels/padding.cu b/src/kernels/padding.cu new file mode 100644 index 0000000..eafcd5e --- /dev/null +++ b/src/kernels/padding.cu @@ -0,0 +1,110 @@ +#include "kernels.h" +#include +#include + +/* + * Reflection padding is from https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/cuda/ReflectionPad.cu + */ +__device__ +inline thrust::pair get_index_mapping2d( + int32_t input_dim_x,int32_t input_dim_y,int32_t output_dim_x, + int32_t output_dim_y,int32_t pad_l,int32_t pad_t,int32_t output_xy, + int32_t y_shift,int32_t z_shift,int32_t n_plane){ + auto input_offset = ((blockIdx.y + y_shift) + (blockIdx.z + z_shift)*n_plane)*input_dim_x*input_dim_y; + auto output_offset = ((blockIdx.y + y_shift) + (blockIdx.z + z_shift)*n_plane)*output_dim_x*output_dim_y; + auto output_x = output_xy % output_dim_x; + auto output_y = output_xy/output_dim_x; + + auto i_start_x = ::max(int32_t(0),-pad_l); + auto i_start_y = ::max(int32_t(0),-pad_t); + auto o_start_x = ::max(int32_t(0),pad_l); + auto o_start_y = ::max(int32_t(0),pad_t); + + auto input_x = ::abs(output_x - pad_l) - ::abs(output_x - (input_dim_x + pad_l -1)) -output_x + 2*pad_l + input_dim_x -1 -o_start_x + i_start_x; + auto input_y = ::abs(output_y - pad_t) - ::abs(output_y - (input_dim_y + pad_t -1)) -output_y + 2*pad_t + input_dim_y -1 -o_start_y + i_start_y; + + return thrust::make_pair(input_offset + input_y*input_dim_x + input_x,output_offset + output_y*output_dim_x+output_x); +} + +__global__ +void reflection_pad2d_out_kernel( + float* input,float* output,int32_t input_dim_x, + int32_t input_dim_y,int32_t pad_t,int32_t pad_b,int32_t pad_l, + int32_t pad_r,int32_t y_shift,int32_t z_shift,int32_t n_plane){ + auto output_xy = threadIdx.x + blockIdx.x * blockDim.x; + auto output_dim_x = input_dim_x + pad_l + pad_r; + auto output_dim_y = input_dim_y + pad_t + pad_b; + + if(output_xy < output_dim_x*output_dim_y){ + auto index_pair = get_index_mapping2d(input_dim_x,input_dim_y,output_dim_x,output_dim_y,pad_l,pad_t,output_xy,y_shift,z_shift,n_plane); + output[index_pair.second] = input[index_pair.first]; + } +} + +int32_t ceilDiv(int32_t a,int32_t b){ + return (a+b-1)/b; +} + + +void reflection_pad2d_out_forward(int32_t pad_h,int32_t pad_w,float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream){ + int32_t pad_l = pad_w; + int32_t pad_r = pad_w; + int32_t pad_t = pad_h; + int32_t pad_b = pad_w; + int32_t output_h = input_h + pad_t + pad_b; + int32_t output_w = input_w + pad_l + pad_r; + int32_t size_y = plane_dim; + int32_t size_z = n_batch; + int32_t output_plane_size = output_h*output_w; + dim3 block_size(output_plane_size>256 ?256:output_plane_size); + for(int32_t block_y=0;block_y(65535)); + for(int32_t block_z=0;block_z(65535)); + + dim3 grid_size(ceilDiv(output_plane_size,static_cast(256)),block_y_size,block_z_size); + reflection_pad2d_out_kernel<<>>(srcData,dstData,input_w,input_h,pad_t,pad_b,pad_l,pad_r,block_y,block_z,plane_dim); + } + } + +} + +/* + * constant padding is inspired from https://github.com/apache/incubator-mxnet/blob/master/src/operator/pad.cu + */ + +__global__ +void constant_pad2d_kernel(dnnType *srcData,dnnType *dstData,const int32_t padT,const int32_t padL,float constant,int32_t n,int32_t c,int32_t i_h,int32_t i_w,int32_t o_h,int32_t o_w){ + int outputPointId = threadIdx.x + blockIdx.x * blockDim.x; + if(outputPointId >= o_h*o_w){ + return ; + } + + int Ny = i_h; + int Nx = i_w; + + int plane = blockIdx.y; + int batch = blockIdx.z; + int outputPointX = outputPointId % o_w; + int outputPointY = outputPointId / o_w; + int checkT = max(0, outputPointY - padT + 1); + int checkB = max(0, padT + Ny - outputPointY); + int checkL = max(0, outputPointX - padL + 1); + int checkR = max(0, padL + Nx - outputPointX); + int inputPointX = min(max(outputPointX - padL, 0), Nx - 1); + int inputPointY = min(max(outputPointY - padT, 0), Ny - 1); + int need_pad = !(checkT * checkB * checkL * checkR); + float value_to_copy = srcData[batch*c*i_h*i_w + plane*i_h*i_w + inputPointY*i_w + inputPointX]; + dstData[batch*c*o_w*o_h + plane*o_h*o_w + outputPointY*o_w + outputPointX] = value_to_copy * (!need_pad) + need_pad*constant; + +} + +void constant_pad2d_forward(dnnType *srcData,dnnType *dstData,int32_t input_h,int32_t input_w,int32_t output_h, + int32_t output_w,int32_t c,int32_t n,int32_t padT,int32_t padL,dnnType constant,cudaStream_t cudaStream){ + int32_t output_plane_size = output_h*output_w; + dim3 block_size(output_plane_size>256 ?256:output_plane_size); + dim3 grid_size(ceilDiv(output_plane_size,static_cast(256)),c,n); + constant_pad2d_kernel<<>>(srcData,dstData,padT,padL,constant,n,c,input_h,input_w,output_h,output_w); + +} + diff --git a/src/pluginsRT/ActivationLeakyRT.cpp b/src/pluginsRT/ActivationLeakyRT.cpp new file mode 100644 index 0000000..2a9bf33 --- /dev/null +++ b/src/pluginsRT/ActivationLeakyRT.cpp @@ -0,0 +1,149 @@ +#include +using namespace nvinfer1; + + +std::vector ActivationLeakyRTPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationLeakyRTPluginCreator::mFC{}; + +ActivationLeakyRT::ActivationLeakyRT(float s) { + slope = s; +} + +ActivationLeakyRT::ActivationLeakyRT(const void *data, size_t length) { + std::cout << "DESERIALIZE LEAKYRT" << std::endl; + const char *buf = reinterpret_cast(data), *bufCheck = buf; + slope = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +ActivationLeakyRT::~ActivationLeakyRT() {} + +int ActivationLeakyRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ActivationLeakyRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + +void ActivationLeakyRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; +} +int ActivationLeakyRT::initialize() NOEXCEPT { + return 0; +} + +size_t ActivationLeakyRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ActivationLeakyRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + activationLEAKYForward( + (dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, slope, + stream); + return 0; + +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationLeakyRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationLEAKYForward( + (dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, slope, + stream); + return 0; +} +#endif + + +size_t ActivationLeakyRT::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int) + 1 * sizeof(float); +} + +void ActivationLeakyRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, size); + assert(buf == a + getSerializationSize()); +} + +bool ActivationLeakyRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ActivationLeakyRT::getPluginType() const NOEXCEPT { + return "ActivationLeakyRT_tkDNN"; +} + +const char *ActivationLeakyRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ActivationLeakyRT::destroy() NOEXCEPT { + delete this; +} + +const char *ActivationLeakyRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); + +} + +void ActivationLeakyRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2* ActivationLeakyRT::clone() const NOEXCEPT { + auto *p = new ActivationLeakyRT(slope); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +ActivationLeakyRTPluginCreator::ActivationLeakyRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationLeakyRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2* ActivationLeakyRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationLeakyRT(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLeakyRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2* ActivationLeakyRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kFLOAT32); + float slope = *(static_cast(fields[0].data)); + auto *pluginObj = new ActivationLeakyRT(slope); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLeakyRTPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationLeakyRT_tkDNN"; +} + +const char* ActivationLeakyRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection* ActivationLeakyRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + diff --git a/src/pluginsRT/ActivationLogisticRT.cpp b/src/pluginsRT/ActivationLogisticRT.cpp new file mode 100644 index 0000000..a3c4ae7 --- /dev/null +++ b/src/pluginsRT/ActivationLogisticRT.cpp @@ -0,0 +1,134 @@ +#include +using namespace nvinfer1; +std::vector ActivationLogisticRTPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationLogisticRTPluginCreator::mFC{}; + +ActivationLogisticRT::ActivationLogisticRT() {} + +ActivationLogisticRT::ActivationLogisticRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +ActivationLogisticRT::~ActivationLogisticRT() {} + +int ActivationLogisticRT::getNbOutputs() const NOEXCEPT { +return 1; +} + +Dims ActivationLogisticRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + +void ActivationLogisticRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, + int nbOutputs, DataType type, PluginFormat format, + int maxBatchSize) NOEXCEPT { + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; +} + +int ActivationLogisticRT::initialize() NOEXCEPT { + return 0; +} + +void ActivationLogisticRT::terminate() NOEXCEPT {} + +size_t ActivationLogisticRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} +#if NV_TENSORRT_MAJOR > 7 +int ActivationLogisticRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + activationLOGISTICForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationLogisticRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationLOGISTICForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +#endif + +size_t ActivationLogisticRT::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int); +} + +void ActivationLogisticRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer); + writeBUF(buf, size); +} + +const char* ActivationLogisticRT::getPluginType() const NOEXCEPT { + return "ActivationLogisticRT_tkDNN"; +} + +const char* ActivationLogisticRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ActivationLogisticRT::destroy() NOEXCEPT { + delete this; +} + +const char* ActivationLogisticRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ActivationLogisticRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +bool ActivationLogisticRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; + //todo assert +} + +IPluginV2* ActivationLogisticRT::clone() const NOEXCEPT { + auto *p = new ActivationLogisticRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +ActivationLogisticRTPluginCreator::ActivationLogisticRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationLogisticRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2* ActivationLogisticRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationLogisticRT(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLogisticRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2* ActivationLogisticRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + auto *pluginObj = new ActivationLogisticRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLogisticRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection* ActivationLogisticRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + +const char *ActivationLogisticRTPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationLogisticRT_tkDNN"; +} \ No newline at end of file diff --git a/src/pluginsRT/ActivationMishRT.cpp b/src/pluginsRT/ActivationMishRT.cpp new file mode 100644 index 0000000..f92629b --- /dev/null +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -0,0 +1,133 @@ +// +// Created by perseusdg on 9/4/21. +// +#include +using namespace nvinfer1; +std::vector ActivationMishRTPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationMishRTPluginCreator::mFC{}; + +ActivationMishRT::ActivationMishRT() { + +} + +ActivationMishRT::~ActivationMishRT() { + +} + +ActivationMishRT::ActivationMishRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ActivationMishRT::getNbOutputs() const NOEXCEPT { return 1; } + +Dims ActivationMishRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { return inputs[0]; } + +void ActivationMishRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT { +assert(format == PluginFormat::kLINEAR); +size = 1; +for (int i = 0; i < outputDims[0].nbDims; i++) +size *= outputDims[0].d[i]; +} + +int ActivationMishRT::initialize() NOEXCEPT { return 0; } + +void ActivationMishRT::terminate() NOEXCEPT {} + +size_t ActivationMishRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +#if NV_TENSORRT_MAJOR > 7 +int ActivationMishRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + activationMishForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationMishRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationMishForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +#endif + +size_t ActivationMishRT::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int); +} + +void ActivationMishRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, size); + assert(buf == a + getSerializationSize()); +} + +const char* ActivationMishRT::getPluginType() const NOEXCEPT { + return "ActivationMishRT_tkDNN"; +} + +const char *ActivationMishRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +bool ActivationMishRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ActivationMishRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ActivationMishRT::setPluginNamespace(const char *plguinNamespace) NOEXCEPT { + mPluginNamespace = plguinNamespace; +} + +IPluginV2 *ActivationMishRT::clone() const NOEXCEPT { + auto *p = new ActivationMishRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + + +ActivationMishRTPluginCreator::ActivationMishRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationMishRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ActivationMishRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ActivationMishRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationMishRT(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ActivationMishRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + auto *pluginObj = new ActivationMishRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ActivationMishRTPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationMishRT_tkDNN"; +} + +const char *ActivationMishRTPluginCreator::getPluginVersion() const NOEXCEPT{ + return "1"; +} + +const PluginFieldCollection *ActivationMishRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + diff --git a/src/pluginsRT/ActivationReLUCeilingRT.cpp b/src/pluginsRT/ActivationReLUCeilingRT.cpp new file mode 100644 index 0000000..c97d4ec --- /dev/null +++ b/src/pluginsRT/ActivationReLUCeilingRT.cpp @@ -0,0 +1,138 @@ +#include +using namespace nvinfer1; + +std::vector ActivationReLUCeilingPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationReLUCeilingPluginCreator::mFC{}; + +ActivationReLUCeiling::ActivationReLUCeiling(const float ceiling) { + this->ceiling = ceiling; +} + +ActivationReLUCeiling::~ActivationReLUCeiling() { + +} + +ActivationReLUCeiling::ActivationReLUCeiling(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + ceiling = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ActivationReLUCeiling::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ActivationReLUCeiling::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { return inputs[0]; } + +void ActivationReLUCeiling::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; +} + +int ActivationReLUCeiling::initialize() NOEXCEPT { return 0; } + +void ActivationReLUCeiling::terminate() NOEXCEPT {} + +size_t ActivationReLUCeiling::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ActivationReLUCeiling::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT { + activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationReLUCeiling::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); + return 0; +} +#endif + +size_t ActivationReLUCeiling::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int) + 1 * sizeof(float); +} + +void ActivationReLUCeiling::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, ceiling); + writeBUF(buf, size); + assert(buf = a + getSerializationSize()); +} + +IPluginV2 *ActivationReLUCeiling::clone() const NOEXCEPT { + auto *p = new ActivationReLUCeiling(ceiling); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +bool ActivationReLUCeiling::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +void ActivationReLUCeiling::destroy() NOEXCEPT { delete this; } + +const char *ActivationReLUCeiling::getPluginType() const NOEXCEPT { + return "ActivationReLUCeilingRT_tkDNN"; +} + +const char *ActivationReLUCeiling::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const char *ActivationReLUCeiling::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ActivationReLUCeiling::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +ActivationReLUCeilingPluginCreator::ActivationReLUCeilingPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationReLUCeilingPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ActivationReLUCeilingPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ActivationReLUCeilingPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationReLUCeiling(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ActivationReLUCeilingPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + float ceiling = *(static_cast(fields[0].data)); + auto *pluginObj = new ActivationReLUCeiling(ceiling); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ActivationReLUCeilingPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationReLUCeilingRT_tkDNN"; +} + +const char *ActivationReLUCeilingPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ActivationReLUCeilingPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + diff --git a/src/pluginsRT/ConstantPaddingRT.cpp b/src/pluginsRT/ConstantPaddingRT.cpp new file mode 100644 index 0000000..546aa7e --- /dev/null +++ b/src/pluginsRT/ConstantPaddingRT.cpp @@ -0,0 +1,204 @@ +#include + +using namespace nvinfer1; + +std::vector ConstantPaddingRTPluginCreator::mPluginAttributes; +PluginFieldCollection ConstantPaddingRTPluginCreator::mFC{}; + +static const char* CONSTANTPADDINGRT_PLUGIN_VERSION{"1"}; +static const char* CONSTANTPADDINGRT_PLUGIN_NAME{"ConstantPaddingRT_tkDNN"}; + +ConstantPaddingRT::ConstantPaddingRT(int32_t padH, int32_t padW, int32_t n, int32_t c, int32_t i_h, int32_t i_w, + int32_t o_h, int32_t o_w, float constant) { + this->padH = padH; + this->padW = padW; + this->n = n; + this->c = c; + this->i_h = i_h; + this->i_w = i_w; + this->o_h = o_h; + this->o_w = o_w; + this->constant = constant; + +} + +ConstantPaddingRT::ConstantPaddingRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufcheck=buf; + padH = readBUF(buf); + padW = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + constant = readBUF(buf); + assert(buf = bufcheck + length); +} + +ConstantPaddingRT::~ConstantPaddingRT() {} + +int ConstantPaddingRT::getNbOutputs() const NOEXCEPT{ + return 1; +} + +Dims ConstantPaddingRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{c,o_h,o_w}; +} + +int ConstantPaddingRT::initialize() NOEXCEPT { + return 0; +} + +void ConstantPaddingRT::terminate() NOEXCEPT { + +} + +size_t ConstantPaddingRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ConstantPaddingRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ConstantPaddingRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; +} +#endif + +size_t ConstantPaddingRT::getSerializationSize() const NOEXCEPT { + return (8*sizeof(int32_t) + 1*sizeof(float)); +} + +void ConstantPaddingRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf,padH); + writeBUF(buf,padW); + writeBUF(buf,i_h); + writeBUF(buf,i_w); + writeBUF(buf,o_h); + writeBUF(buf,o_w); + writeBUF(buf,n); + writeBUF(buf,c); + writeBUF(buf,constant); +} + +void ConstantPaddingRT::destroy() NOEXCEPT { + delete this; +} + +const char* ConstantPaddingRT::getPluginType() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_NAME; +} + +const char* ConstantPaddingRT::getPluginVersion() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_VERSION; +} + +const char* ConstantPaddingRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ConstantPaddingRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ConstantPaddingRT::clone() const NOEXCEPT { + auto *p = new ConstantPaddingRT(padH,padW,n,c,i_h,i_w,o_h,o_w,constant); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType ConstantPaddingRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, + int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ConstantPaddingRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ConstantPaddingRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ConstantPaddingRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ConstantPaddingRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, + int32_t nbOutputs, const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ConstantPaddingRT::detachFromContext() NOEXCEPT { + +} + +bool ConstantPaddingRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + + + +ConstantPaddingRTPluginCreator::ConstantPaddingRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ConstantPaddingRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ConstantPaddingRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ConstantPaddingRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ConstantPaddingRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ConstantPaddingRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int padH = *(static_cast(fields[0].data)); + int padW = *(static_cast(fields[1].data)); + int inputH = *(static_cast(fields[2].data)); + int inputW = *(static_cast(fields[3].data)); + int outputH = *(static_cast(fields[4].data)); + int outputW = *(static_cast(fields[5].data)); + int n = *(static_cast(fields[6].data)); + int c = *(static_cast(fields[7].data)); + float constant = *(static_cast(fields[8].data)); + auto *pluginObj = new ConstantPaddingRT(padH,padW,n,c,inputH,inputW,outputH,outputW,constant); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ConstantPaddingRTPluginCreator::getPluginName() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_NAME; +} + +const char *ConstantPaddingRTPluginCreator::getPluginVersion() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ConstantPaddingRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp new file mode 100644 index 0000000..6af3587 --- /dev/null +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -0,0 +1,361 @@ +#include + +#include +using namespace nvinfer1; +using namespace tk::dnn; + +std::vector DeformableConvRTPluginCreator::mPluginAttributes; +PluginFieldCollection DeformableConvRTPluginCreator::mFC{}; + +static const char* DEFORMABLECONVRT_PLUGIN_VERSION{"1"}; +static const char* DEFORMABLECONVRT_PLUGIN_NAME{"DeformableConvRT_tkDNN"}; + + +DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, int deformableGroup, + int i_n, int i_c, int i_h, int i_w, int o_n, int o_c, int o_h, int o_w,std::vector data_H,std::vector bias2_H, + std::vector ones_d1_h,std::vector ones_d2_h,std::vector offsetH,std::vector maskH,int height_ones,int width_ones,int dim_ones) { + this->chunk_dim = chunk_dim; + this->kh = kh; + this->kw = kw; + this->sh = sh; + this->sw = sw; + this->ph = ph; + this->pw = pw; + this->deformableGroup = deformableGroup; + this->i_n = i_n; + this->i_c = i_c; + this->i_h = i_h; + this->i_w = i_w; + this->o_n = o_n; + this->o_c = o_c; + this->o_h = o_h; + this->o_w = o_w; + this->mask_v = std::move(maskH); + this->offset_v = std::move(offsetH); + this->ones_d2_v = std::move(ones_d2_h); + this->ones_d1_v = std::move(ones_d1_h); + this->data_d_v = std::move(data_H); + this->bias2_d_v = std::move(bias2_H); + this->height_ones = height_ones; + this->width_ones = width_ones; + this->dim_ones = dim_ones; + + checkCuda( cudaMalloc(&data_d, i_c * o_c * kh * kw * 1 * sizeof(dnnType))); + checkCuda( cudaMalloc(&bias2_d, o_c*sizeof(dnnType))); + checkCuda( cudaMalloc(&ones_d1, height_ones * width_ones * sizeof(dnnType))); + checkCuda( cudaMalloc(&offset, 2*chunk_dim*sizeof(dnnType))); + checkCuda( cudaMalloc(&mask, chunk_dim*sizeof(dnnType))); + checkCuda( cudaMalloc(&ones_d2, dim_ones*sizeof(dnnType))); + if(!data_d_v.empty() && !bias2_d_v.empty() && !ones_d1_v.empty() && !ones_d2_v.empty() && !mask_v.empty() && !offset_v.empty()) { + checkCuda(cudaMemcpy(data_d, data_d_v.data(), sizeof(dnnType) * data_d_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(bias2_d, bias2_d_v.data(), sizeof(dnnType) * bias2_d_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(ones_d1, ones_d1_v.data(), sizeof(dnnType) * ones_d1_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(offset, offset_v.data(), sizeof(dnnType) * offset_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(mask, mask_v.data(), sizeof(dnnType) * mask_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(ones_d2, ones_d2_v.data(), sizeof(dnnType) * ones_d2_v.size(), cudaMemcpyHostToDevice)); + } + + +} + +DeformableConvRT::~DeformableConvRT() { + checkCuda( cudaFree(data_d) ); + checkCuda( cudaFree(bias2_d) ); + checkCuda( cudaFree(ones_d1) ); + checkCuda( cudaFree(offset) ); + checkCuda( cudaFree(mask) ); + checkCuda( cudaFree(ones_d2) ); +} + +DeformableConvRT::DeformableConvRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + chunk_dim = readBUF(buf); + kh = readBUF(buf); + kw = readBUF(buf); + sh = readBUF(buf); + sw = readBUF(buf); + ph = readBUF(buf); + pw = readBUF(buf); + deformableGroup = readBUF(buf); + i_n = readBUF(buf); + i_c = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + o_n = readBUF(buf); + o_c = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + height_ones = readBUF(buf); + width_ones = readBUF(buf); + dim_ones = readBUF(buf); + offset_v.resize(chunk_dim*2); + for(int i=0;i(buf); + mask_v.resize(chunk_dim); + for(int i=0;i(buf); + data_d_v.resize(i_c*o_c*kh*kw*1); + for(int i=0;i<(i_c*o_c*kh*kw*1);i++) + data_d_v[i] = readBUF(buf); + bias2_d_v.resize(o_c); + for(int i=0; i < o_c; i++) + bias2_d_v[i] = readBUF(buf); + ones_d1_v.resize(height_ones*width_ones); + for(int i=0; i(buf); + ones_d2_v.resize(dim_ones); + for(int i=0; i(buf); + assert(buf == bufCheck + length); + +} + +int DeformableConvRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims DeformableConvRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{o_c, o_h, o_w}; +} + +int DeformableConvRT::initialize() NOEXCEPT { + return 0; +} + +void DeformableConvRT::terminate() NOEXCEPT {} + +size_t DeformableConvRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT {return 0;} + +#if NV_TENSORRT_MAJOR > 7 +int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); + + // split conv2d outputs into offset to mask + for(int b=0; b(outputs[0]), ones_d2, + kh, kw, + sh, sw, + ph, pw, + 1, 1, + deformableGroup, b, + i_n, i_c, i_h, i_w, + o_n, o_c, o_h, o_w, + chunk_dim); + } + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t DeformableConvRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); + + // split conv2d outputs into offset to mask + for(int b=0; b(outputs[0]), ones_d2, + kh, kw, + sh, sw, + ph, pw, + 1, 1, + deformableGroup, b, + i_n, i_c, i_h, i_w, + o_n, o_c, o_h, o_w, + chunk_dim); + } + return 0; +} +#endif + +size_t DeformableConvRT::getSerializationSize() const NOEXCEPT { + return 19 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + + o_c * sizeof(dnnType) + height_ones * width_ones * sizeof(dnnType) + dim_ones * sizeof(dnnType); +} + +void DeformableConvRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, chunk_dim); + writeBUF(buf, kh); + writeBUF(buf, kw); + writeBUF(buf, sh); + writeBUF(buf, sw); + writeBUF(buf, ph); + writeBUF(buf, pw); + writeBUF(buf, deformableGroup); + writeBUF(buf, i_n); + writeBUF(buf, i_c); + writeBUF(buf, i_h); + writeBUF(buf, i_w); + writeBUF(buf, o_n); + writeBUF(buf, o_c); + writeBUF(buf, o_h); + writeBUF(buf, o_w); + writeBUF(buf,height_ones); + writeBUF(buf,width_ones); + writeBUF(buf,dim_ones); + for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType +DeformableConvRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void DeformableConvRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + handle = cublasContext; + +} + +bool DeformableConvRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool DeformableConvRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void DeformableConvRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +void DeformableConvRT::detachFromContext() NOEXCEPT { + +} + +bool DeformableConvRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void DeformableConvRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *DeformableConvRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *DeformableConvRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new DeformableConvRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *DeformableConvRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int chunk_dim = *(static_cast(fields[0].data)); + int kh = *(static_cast(fields[1].data)); + int kw = *(static_cast(fields[2].data)); + int sh = *(static_cast(fields[3].data)); + int sw = *(static_cast(fields[4].data)); + int ph = *(static_cast(fields[5].data)); + int pw = *(static_cast(fields[6].data)); + int deformableGroup = *(static_cast(fields[7].data)); + int i_n = *(static_cast(fields[8].data)); + int i_c = *(static_cast(fields[9].data)); + int i_h = *(static_cast(fields[10].data)); + int i_w = *(static_cast(fields[11].data)); + int o_n = *(static_cast(fields[12].data)); + int o_c = *(static_cast(fields[13].data)); + int o_h = *(static_cast(fields[14].data)); + int o_w = *(static_cast(fields[15].data)); + std::vector mask_v(static_cast(fields[16].data),static_cast(fields[16].data)+fields[16].length); + std::vector offset_v(static_cast(fields[17].data),static_cast(fields[17].data)+fields[17].length); + std::vector ones_d2_v(static_cast(fields[18].data),static_cast(fields[18].data)+fields[18].length); + std::vector ones_d1_v(static_cast(fields[19].data),static_cast(fields[19].data)+fields[19].length); + std::vector data_d_v(static_cast(fields[20].data),static_cast(fields[20].data)+fields[20].length); + std::vector bias2_d_v(static_cast(fields[21].data),static_cast(fields[21].data)+fields[21].length); + int height_ones = *(static_cast(fields[22].data)); + int width_ones = *(static_cast(fields[23].data)); + int dim_ones = *(static_cast(fields[24].data)); + auto *pluginObj = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,data_d_v,bias2_d_v,ones_d1_v,ones_d2_v,offset_v,mask_v,height_ones,width_ones,dim_ones); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *DeformableConvRTPluginCreator::getPluginName() const NOEXCEPT { + return DEFORMABLECONVRT_PLUGIN_NAME; +} + +const char *DeformableConvRTPluginCreator::getPluginVersion() const NOEXCEPT { + return DEFORMABLECONVRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *DeformableConvRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp new file mode 100644 index 0000000..0e500b3 --- /dev/null +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -0,0 +1,215 @@ +#include +using namespace nvinfer1; + +std::vector FlattenConcatRTPluginCreator::mPluginAttributes; +PluginFieldCollection FlattenConcatRTPluginCreator::mFC{}; + +static const char* FLATTENCONCATRT_PLUGIN_VERSION{"1"}; +static const char* FLATTENCONCATRT_PLUGIN_NAME{"FlattenConcatRT_tkDNN"}; + +FlattenConcatRT::FlattenConcatRT(int c, int h, int w, int rows, int cols) { + this->c = c; + this->h = h; + this->w = w; + this->rows = rows; + this->cols = cols; +} + +FlattenConcatRT::FlattenConcatRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck=buf; + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + rows = readBUF(buf); + cols = readBUF(buf); + assert(buf == bufCheck + length); +} + +FlattenConcatRT::~FlattenConcatRT() {} + +int FlattenConcatRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims FlattenConcatRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; +} + +int FlattenConcatRT::initialize() NOEXCEPT { + return 0; +} + +void FlattenConcatRT::terminate() NOEXCEPT { + +} + +size_t FlattenConcatRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int FlattenConcatRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + checkERROR( cublasSetStream(handle, stream) ); + for(int i=0; i(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + checkERROR( cublasSetStream(handle, stream) ); + for(int i=0; i(buffer),*a = buf; + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + writeBUF(buf, rows); + writeBUF(buf, cols); + assert(buf == a + getSerializationSize()); +} + +void FlattenConcatRT::destroy() NOEXCEPT { + delete this; +} + + + +const char *FlattenConcatRT::getPluginType() const NOEXCEPT { + return FLATTENCONCATRT_PLUGIN_NAME; +} + +const char *FlattenConcatRT::getPluginVersion() const NOEXCEPT { + return FLATTENCONCATRT_PLUGIN_VERSION; +} + +const char *FlattenConcatRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *FlattenConcatRT::clone() const NOEXCEPT { + auto* p = new FlattenConcatRT(c, h, w, rows, cols); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType FlattenConcatRT::getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT +{ + return DataType::kFLOAT; +} + + +void FlattenConcatRT::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT +{ + handle = cublasContext; +} + +bool FlattenConcatRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT +{ + return false; +} + +bool FlattenConcatRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT +{ + return false; +} + +void FlattenConcatRT::detachFromContext() NOEXCEPT +{ +} + +void +FlattenConcatRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void FlattenConcatRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *FlattenConcatRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new FlattenConcatRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField* fields = fc->fields; + int c = *(static_cast(fields[0].data)); + int h = *(static_cast(fields[1].data)); + int w = *(static_cast(fields[2].data)); + int rows = *(static_cast(fields[3].data)); + int cols = *(static_cast(fields[4].data)); + auto* pluginObj = new FlattenConcatRT(c, h, w, rows, cols); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *FlattenConcatRTPluginCreator::getPluginName() const NOEXCEPT { + return FLATTENCONCATRT_PLUGIN_NAME; +} + +const char *FlattenConcatRTPluginCreator::getPluginVersion() const NOEXCEPT { + return FLATTENCONCATRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *FlattenConcatRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp new file mode 100644 index 0000000..4254ac5 --- /dev/null +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -0,0 +1,212 @@ +#include +using namespace nvinfer1; + +std::vector MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; +PluginFieldCollection MaxPoolFixedSizeRTPluginCreator::mFC{}; + +static const char* MAXPOOLFIXEDSIZERT_PLUGIN_VERSION{"1"}; +static const char* MAXPOOLFIXEDSIZERT_PLUGIN_NAME{"MaxPoolingFixedSizeRT_tkDNN"}; + +MaxPoolFixedSizeRT::MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding){ + this->c = c; + this->h = h; + this->w = w; + this->n = n; + this->stride_H = strideH; + this->stride_W = strideW; + this->winSize = winSize; + this->padding = padding; +} + +MaxPoolFixedSizeRT::MaxPoolFixedSizeRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + n = readBUF(buf); + stride_H = readBUF(buf); + stride_W = readBUF(buf); + winSize = readBUF(buf); + padding = readBUF(buf); + assert(buf == bufCheck + length); +} + +MaxPoolFixedSizeRT::~MaxPoolFixedSizeRT() { + +} + +int MaxPoolFixedSizeRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims MaxPoolFixedSizeRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{this->c, this->h, this->w}; +} + +int MaxPoolFixedSizeRT::initialize() NOEXCEPT { + return 0; +} + +void MaxPoolFixedSizeRT::terminate() NOEXCEPT { + +} + +size_t MaxPoolFixedSizeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t MaxPoolFixedSizeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); + return 0; +} +#endif + + +size_t MaxPoolFixedSizeRT::getSerializationSize() const NOEXCEPT { + return 8*sizeof(int); +} + +void MaxPoolFixedSizeRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, this->c); + writeBUF(buf, this->h); + writeBUF(buf, this->w); + writeBUF(buf, this->n); + writeBUF(buf, this->stride_H); + writeBUF(buf, this->stride_W); + writeBUF(buf, this->winSize); + writeBUF(buf, this->padding); + assert(buf == a + getSerializationSize()); +} + +void MaxPoolFixedSizeRT::destroy() NOEXCEPT { +delete this; +} + +bool MaxPoolFixedSizeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *MaxPoolFixedSizeRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void MaxPoolFixedSizeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *MaxPoolFixedSizeRT::getPluginType() const NOEXCEPT { + return MAXPOOLFIXEDSIZERT_PLUGIN_NAME; +} + +const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { + return MAXPOOLFIXEDSIZERT_PLUGIN_VERSION; +} + +IPluginV2Ext *MaxPoolFixedSizeRT::clone() const NOEXCEPT { + auto *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType +MaxPoolFixedSizeRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void MaxPoolFixedSizeRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool MaxPoolFixedSizeRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool MaxPoolFixedSizeRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void +MaxPoolFixedSizeRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void MaxPoolFixedSizeRT::detachFromContext() NOEXCEPT { + IPluginV2Ext::detachFromContext(); +} + +MaxPoolFixedSizeRTPluginCreator::MaxPoolFixedSizeRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void MaxPoolFixedSizeRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { + auto *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int c = *(static_cast(fields[0].data)); + int h = *(static_cast(fields[1].data)); + int w = *(static_cast(fields[2].data)); + int n = *(static_cast(fields[3].data)); + int stride_H = *(static_cast(fields[4].data)); + int stride_W = *(static_cast(fields[5].data)); + int winSize = *(static_cast(fields[6].data)); + int padding = *(static_cast(fields[7].data)); + auto *pluginObj = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginName() const NOEXCEPT { + return MAXPOOLFIXEDSIZERT_PLUGIN_NAME; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginVersion() const NOEXCEPT { + return MAXPOOLFIXEDSIZERT_PLUGIN_VERSION; +} + +const PluginFieldCollection *MaxPoolFixedSizeRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/ReflectionPadding.cpp b/src/pluginsRT/ReflectionPadding.cpp new file mode 100644 index 0000000..21d897a --- /dev/null +++ b/src/pluginsRT/ReflectionPadding.cpp @@ -0,0 +1,202 @@ +#include +using namespace nvinfer1; + +std::vector ReflectionPaddingRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReflectionPaddingRTPluginCreator::mFC{}; + +static const char* REFLECTIONPADDINGRT_PLUGIN_VERSION{"1"}; +static const char* REFLECTIONPADDINGRT_PLUGIN_NAME{"ReflectionPaddingRT_tkDNN"}; + +ReflectionPaddingRT::ReflectionPaddingRT(int32_t padH, int32_t padW, int32_t input_h, int32_t input_w, int32_t output_h, + int32_t output_w, int32_t c, int32_t n) { + this->padH = padH; + this->padW = padW; + this->input_h = input_h; + this->input_w = input_w; + this->output_h = output_h; + this->output_w = output_w; + this->n = n; + this->c = c; +} + +ReflectionPaddingRT::ReflectionPaddingRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufcheck=buf; + padH = readBUF(buf); + padW = readBUF(buf); + input_h = readBUF(buf); + input_w = readBUF(buf); + output_h = readBUF(buf); + output_w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + assert(buf = bufcheck + length); +} + +ReflectionPaddingRT::~ReflectionPaddingRT() {} + +int ReflectionPaddingRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ReflectionPaddingRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{c,output_h,output_w}; +} + +int ReflectionPaddingRT::initialize() NOEXCEPT { + return 0; +} + +void ReflectionPaddingRT::terminate() NOEXCEPT { + +} + +size_t ReflectionPaddingRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ReflectionPaddingRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + reflection_pad2d_out_forward(padH,padW,srcData,dstData,input_h,input_w,c,n,stream); + return 0; +} + +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ReflectionPaddingRT::enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream){ + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + reflection_pad2d_out_forward(padH,padW,srcData,dstData,input_h,input_w,c,n,stream); + return 0; +} +#endif + + +size_t ReflectionPaddingRT::getSerializationSize() const NOEXCEPT { + return 8*sizeof(int32_t); +} + +void ReflectionPaddingRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf,padH); + writeBUF(buf,padW); + writeBUF(buf,input_h); + writeBUF(buf,input_w); + writeBUF(buf,output_h); + writeBUF(buf,output_w); + writeBUF(buf,n); + writeBUF(buf,c); +} + +void ReflectionPaddingRT::destroy() NOEXCEPT { + delete this; +} + +const char *ReflectionPaddingRT::getPluginType() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_NAME; +} + +const char *ReflectionPaddingRT::getPluginVersion() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_VERSION; +} + +const char *ReflectionPaddingRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ReflectionPaddingRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ReflectionPaddingRT::clone() const NOEXCEPT { + auto *p = new ReflectionPaddingRT(padH,padW,input_h,input_w,output_h,output_w,c,n); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType +ReflectionPaddingRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ReflectionPaddingRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { +} + +bool ReflectionPaddingRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ReflectionPaddingRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void +ReflectionPaddingRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ReflectionPaddingRT::detachFromContext() NOEXCEPT { + +} + +bool ReflectionPaddingRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + + +ReflectionPaddingRTPluginCreator::ReflectionPaddingRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ReflectionPaddingRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ReflectionPaddingRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ReflectionPaddingRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ReflectionPaddingRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext * +ReflectionPaddingRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int padH = *(static_cast(fields[0].data)); + int padW = *(static_cast(fields[1].data)); + int inputH = *(static_cast(fields[2].data)); + int inputW = *(static_cast(fields[3].data)); + int outputH = *(static_cast(fields[4].data)); + int outputW = *(static_cast(fields[5].data)); + int n = *(static_cast(fields[6].data)); + int c = *(static_cast(fields[7].data)); + auto *pluginObj = new ReflectionPaddingRT(padH,padW,inputH,inputW,outputH,outputW,c,n); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReflectionPaddingRTPluginCreator::getPluginName() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_NAME; +} + +const char *ReflectionPaddingRTPluginCreator::getPluginVersion() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ReflectionPaddingRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp new file mode 100644 index 0000000..c31bbe6 --- /dev/null +++ b/src/pluginsRT/RegionRT.cpp @@ -0,0 +1,229 @@ +#include +using namespace nvinfer1; + +std::vector RegionRTPluginCreator::mPluginAttributes; +PluginFieldCollection RegionRTPluginCreator::mFC{}; + +static const char* REGIONRT_PLUGIN_VERSION{"1"}; +static const char* REGIONRT_PLUGIN_NAME{"RegionRT_tkDNN"}; + +RegionRT::RegionRT(int classes, int coords, int num,int c,int h,int w) { + this->classes = classes; + this->coords = coords; + this->num = num; + this->c = c; + this->h = h; + this->w = w; +} + +RegionRT::~RegionRT() {} + +RegionRT::RegionRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck=buf; + classes = readBUF(buf); + coords = readBUF(buf); + num = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck+length); +} + +int RegionRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims RegionRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + + +int RegionRT::initialize() NOEXCEPT {return 0;} + +void RegionRT::terminate() NOEXCEPT {} + +size_t RegionRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +#if NV_TENSORRT_MAJOR > 7 +int RegionRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + for (int b = 0; b < batchSize; ++b){ + for(int n = 0; n < num; ++n){ + int index = entry_index(b, n*w*h, 0); + activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); + + index = entry_index(b, n*w*h, coords); + activationLOGISTICForward(srcData + index, dstData + index, w*h, stream); + } + } + + //softmax start + int index = entry_index(0, 0, coords + 1); + softmaxForward( srcData + index, classes, batchSize*num, + (c*h*w)/num, + w*h, 1, w*h, 1, dstData + index, stream); + + return 0; +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t RegionRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + for (int b = 0; b < batchSize; ++b){ + for(int n = 0; n < num; ++n){ + int index = entry_index(b, n*w*h, 0); + activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); + + index = entry_index(b, n*w*h, coords); + activationLOGISTICForward(srcData + index, dstData + index, w*h, stream); + } + } + + //softmax start + int index = entry_index(0, 0, coords + 1); + softmaxForward( srcData + index, classes, batchSize*num, + (c*h*w)/num, + w*h, 1, w*h, 1, dstData + index, stream); + + return 0; +} +#endif + +size_t RegionRT::getSerializationSize() const NOEXCEPT { + return 6*sizeof(int); +} + +void RegionRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, classes); + writeBUF(buf, coords); + writeBUF(buf, num); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +const char *RegionRT::getPluginType() const NOEXCEPT { + return REGIONRT_PLUGIN_NAME; +} + +const char *RegionRT::getPluginVersion() const NOEXCEPT { + return REGIONRT_PLUGIN_VERSION; +} + +void RegionRT::destroy() NOEXCEPT { delete this; } + +const char *RegionRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void RegionRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +bool RegionRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +IPluginV2Ext *RegionRT::clone() const NOEXCEPT { + auto *p = new RegionRT(classes,coords,num,c,h,w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType RegionRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void RegionRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool RegionRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool RegionRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void RegionRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void RegionRT::detachFromContext() NOEXCEPT { + +} + + +RegionRTPluginCreator::RegionRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void RegionRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *RegionRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *RegionRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new RegionRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 6); + for(int i=0;i<6;i++){ + assert(fields[i].type == PluginFieldType::kINT32); + } + int classes = *(static_cast(fields[0].data)); + int coords = *(static_cast(fields[1].data)); + int num = *(static_cast(fields[2].data)); + int c = *(static_cast(fields[3].data)); + int h = *(static_cast(fields[4].data)); + int w = *(static_cast(fields[5].data)); + auto *pluginObj = new RegionRT(classes,coords,num,c,h,w); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *RegionRTPluginCreator::getPluginName() const NOEXCEPT { + return REGIONRT_PLUGIN_NAME; +} + +const char *RegionRTPluginCreator::getPluginVersion() const NOEXCEPT { + return REGIONRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *RegionRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp new file mode 100644 index 0000000..8f0fa12 --- /dev/null +++ b/src/pluginsRT/ReorgRT.cpp @@ -0,0 +1,194 @@ +#include +using namespace nvinfer1; + +std::vector ReorgRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReorgRTPluginCreator::mFC{}; + +static const char* REORGRT_PLUGIN_VERSION{"1"}; +static const char* REORGRT_PLUGIN_NAME{"ReorgRT_tkDNN"}; + +ReorgRT::ReorgRT(int stride,int c,int h,int w) { + this->stride = stride; + this->c = c; + this->h = h; + this->w = w; +} + +ReorgRT::~ReorgRT() {} + +ReorgRT::ReorgRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + stride = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ReorgRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ReorgRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; +} + + +int ReorgRT::initialize() NOEXCEPT { + return 0; +} + +void ReorgRT::terminate() NOEXCEPT {} + +size_t ReorgRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ReorgRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT { + reorgForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, c, h, w, stride, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ReorgRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + reorgForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, c, h, w, stride, stream); + return 0; +} +#endif + + +size_t ReorgRT::getSerializationSize() const NOEXCEPT { + return 4*sizeof(int); +} + +void ReorgRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, stride); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool ReorgRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ReorgRT::getPluginType() const NOEXCEPT { + return REORGRT_PLUGIN_NAME; +} + +const char *ReorgRT::getPluginVersion() const NOEXCEPT { + return REORGRT_PLUGIN_VERSION; +} + +void ReorgRT::destroy() NOEXCEPT { + delete this; +} + +const char *ReorgRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ReorgRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ReorgRT::clone() const NOEXCEPT { + auto *p = new ReorgRT(stride,c,h,w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType ReorgRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ReorgRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ReorgRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool ReorgRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ReorgRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ReorgRT::detachFromContext() NOEXCEPT { + +} + +ReorgRTPluginCreator::ReorgRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ReorgRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ReorgRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ReorgRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ReorgRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 4); + for(int i=0;i<4;i++){ + assert(fields[1].type == PluginFieldType::kINT32); + } + int stride = *(static_cast(fields[0].data)); + int c = *(static_cast(fields[1].data)); + int h = *(static_cast(fields[2].data)); + int w = *(static_cast(fields[3].data)); + + auto *pluginObj = new ReorgRT(stride,c,h,w); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReorgRTPluginCreator::getPluginName() const NOEXCEPT { + return REORGRT_PLUGIN_NAME; +} + +const char *ReorgRTPluginCreator::getPluginVersion() const NOEXCEPT { + return REORGRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ReorgRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp new file mode 100644 index 0000000..8d81a8d --- /dev/null +++ b/src/pluginsRT/ReshapeRT.cpp @@ -0,0 +1,197 @@ +#include +using namespace nvinfer1; + +std::vector ReshapeRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReshapeRTPluginCreator::mFC{}; + +static const char* RESHAPERT_PLUGIN_VERSION{"1"}; +static const char* RESHAPERT_PLUGIN_NAME{"ReshapeRT_tkDNN"}; + +ReshapeRT::ReshapeRT(int n,int c,int h,int w) { + this->n = n; + this->c = c; + this->h = h; + this->w = w; +} + +ReshapeRT::ReshapeRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + n = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +ReshapeRT::~ReshapeRT() {} + +int ReshapeRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ReshapeRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{ c,h,w} ; +} + +int ReshapeRT::initialize() NOEXCEPT { + return 0; +} + +void ReshapeRT::terminate() NOEXCEPT {} + +size_t ReshapeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + std::cout << "C : " << c << "H : " << h << "w :" << w << std::endl; + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + return 0; +} +#endif + + +size_t ReshapeRT::getSerializationSize() const NOEXCEPT { + return 4*sizeof(int); +} + +void ReshapeRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a = buf; + writeBUF(buf, n); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool ReshapeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ReshapeRT::getPluginType() const NOEXCEPT { + return RESHAPERT_PLUGIN_NAME; +} + +const char *ReshapeRT::getPluginVersion() const NOEXCEPT { + return RESHAPERT_PLUGIN_VERSION; +} + +void ReshapeRT::destroy() NOEXCEPT { + delete this; +} + +const char *ReshapeRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ReshapeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ReshapeRT::clone() const NOEXCEPT { + auto *p = new ReshapeRT(n,c,h,w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType ReshapeRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ReshapeRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool +ReshapeRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool ReshapeRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ReshapeRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +void ReshapeRT::detachFromContext() NOEXCEPT { + +} + +ReshapeRTPluginCreator::ReshapeRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ReshapeRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ReshapeRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ReshapeRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ReshapeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 4); + for(int i=0;i<4;i++){ + assert(fields[1].type == PluginFieldType::kINT32); + } + int n = *(static_cast(fields[0].data)); + int c = *(static_cast(fields[1].data)); + int h = *(static_cast(fields[2].data)); + int w = *(static_cast(fields[3].data)); + + auto *pluginObj = new ReshapeRT(n,c,h,w); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReshapeRTPluginCreator::getPluginName() const NOEXCEPT { + return RESHAPERT_PLUGIN_NAME; +} + +const char *ReshapeRTPluginCreator::getPluginVersion() const NOEXCEPT { + return RESHAPERT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ReshapeRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp new file mode 100644 index 0000000..1068f60 --- /dev/null +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -0,0 +1,198 @@ +#include +using namespace nvinfer1; + +std::vector ResizeLayerRTPluginCreator::mPluginAttributes; +PluginFieldCollection ResizeLayerRTPluginCreator::mFC{}; + + +ResizeLayerRT::ResizeLayerRT(int oc, int oh, int ow,int ic,int ih,int iw) { + this->o_c = oc; + this->o_h = oh; + this->o_w = ow; + this->i_c = ic; + this->i_h = ih; + this->i_w = iw; +} + +ResizeLayerRT::ResizeLayerRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + o_c = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + i_c = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + assert(buf == bufCheck + length); +} + +ResizeLayerRT::~ResizeLayerRT() {} + +int ResizeLayerRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ResizeLayerRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{o_c, o_h, o_w}; +} + +int ResizeLayerRT::initialize() NOEXCEPT { + return 0; +} + +void ResizeLayerRT::terminate() NOEXCEPT {} + +size_t ResizeLayerRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +#if NV_TENSORRT_MAJOR > 7 +int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + resizeForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ResizeLayerRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + resizeForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); + return 0; +} +#endif + +size_t ResizeLayerRT::getSerializationSize() const NOEXCEPT { + return 6*sizeof(int); +} + +void ResizeLayerRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, o_c); + writeBUF(buf, o_h); + writeBUF(buf, o_w); + writeBUF(buf, i_c); + writeBUF(buf, i_h); + writeBUF(buf, i_w); + assert(buf == a + getSerializationSize()); +} + +bool ResizeLayerRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ResizeLayerRT::getPluginType() const NOEXCEPT { + return "ResizeLayerRT_tkDNN"; +} + +const char *ResizeLayerRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ResizeLayerRT::destroy() NOEXCEPT { + delete this; +} + +const char *ResizeLayerRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ResizeLayerRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ResizeLayerRT::clone() const NOEXCEPT { + auto *p = new ResizeLayerRT(o_c,o_h,o_w,i_c,i_h,i_w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType +ResizeLayerRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ResizeLayerRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ResizeLayerRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ResizeLayerRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ResizeLayerRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ResizeLayerRT::detachFromContext() NOEXCEPT { + +} + +ResizeLayerRTPluginCreator::ResizeLayerRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ResizeLayerRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ResizeLayerRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ResizeLayerRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ResizeLayerRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 6); + for(int i=0;i<6;i++){ + assert(fields[i].type == PluginFieldType::kINT32); + } + int oc = *(static_cast(fields[0].data)); + int oh = *(static_cast(fields[1].data)); + int ow = *(static_cast(fields[2].data)); + int ic = *(static_cast(fields[3].data)); + int ih = *(static_cast(fields[4].data)); + int iw = *(static_cast(fields[5].data)); + auto *pluginObj = new ResizeLayerRT(oc,oh,ow,ic,ih,iw); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ResizeLayerRTPluginCreator::getPluginName() const NOEXCEPT { + return "ResizeLayerRT_tkDNN"; +} + +const char *ResizeLayerRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ResizeLayerRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/RouteRT.cpp b/src/pluginsRT/RouteRT.cpp new file mode 100644 index 0000000..3c3ca79 --- /dev/null +++ b/src/pluginsRT/RouteRT.cpp @@ -0,0 +1,197 @@ +#include +using namespace nvinfer1; + +std::vector RouteRTPluginCreator::mPluginAttributes; +PluginFieldCollection RouteRTPluginCreator::mFC{}; + + +RouteRT::RouteRT(int groups, int group_id) { + this->groups = groups; + this->group_id = group_id; +} + +RouteRT::~RouteRT() {} + +RouteRT::RouteRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + groups = readBUF(buf); + group_id = readBUF(buf); + in = readBUF(buf); + for(int i=0;i (buf); + } + c= readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +int RouteRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims RouteRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + int out_c = 0; + for(int i=0; i 7 +int RouteRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *dstData = reinterpret_cast(outputs[0]); + for(int b=0; b(inputs[i]); + int in_dim = c_in[i]*h*w; + int part_in_dim = in_dim / this->groups; + checkCuda( cudaMemcpyAsync(dstData + b*c*w*h + offset, input + b*c*w*h*groups + this->group_id*part_in_dim, part_in_dim*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream) ); + offset += part_in_dim; + } + } + return 0; +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t RouteRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *dstData = reinterpret_cast(outputs[0]); + for(int b=0; b(inputs[i]); + int in_dim = c_in[i]*h*w; + int part_in_dim = in_dim / this->groups; + checkCuda( cudaMemcpyAsync(dstData + b*c*w*h + offset, input + b*c*w*h*groups + this->group_id*part_in_dim, part_in_dim*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream) ); + offset += part_in_dim; + } + } + return 0; +} +#endif + +size_t RouteRT::getSerializationSize() const NOEXCEPT { + return (6+MAX_INPUTS)*sizeof(int); +} + +void RouteRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, groups); + writeBUF(buf, group_id); + writeBUF(buf, in); + for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +RouteRTPluginCreator::RouteRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void RouteRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *RouteRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *RouteRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new RouteRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *RouteRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 2); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + int groups = *(static_cast(fields[0].data)); + int group_id = *(static_cast(fields[1].data)); + RouteRT *pluginObj = new RouteRT(groups,group_id); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *RouteRTPluginCreator::getPluginName() const NOEXCEPT { + return "RouteRT_tkDNN"; +} + +const char *RouteRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *RouteRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp new file mode 100644 index 0000000..606f66e --- /dev/null +++ b/src/pluginsRT/ShortcutRT.cpp @@ -0,0 +1,211 @@ +#include +using namespace nvinfer1; + +std::vector ShortcutRTPluginCreator::mPluginAttributes; +PluginFieldCollection ShortcutRTPluginCreator::mFC{}; + +static const char* SHORTCUTRT_PLUGIN_VERSION{"1"}; +static const char* SHORTCUTRT_PLUGIN_NAME{"ShortcutRT_tkDNN"}; + +ShortcutRT::ShortcutRT(int bc,int bh,int bw,int c,int h,int w,bool mul) { + this->bc = bc; + this->bh = bh; + this->bw = bw; + this->mul = mul; + this->c = c; + this->h = h; + this->w = w; +} + +ShortcutRT::~ShortcutRT() {} + +ShortcutRT::ShortcutRT(const void *data, size_t length) { + const char* buf =reinterpret_cast(data),*bufCheck = buf; + bc = readBUF(buf); + bh = readBUF(buf); + bw = readBUF(buf); + mul = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ShortcutRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ShortcutRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; +} + +int ShortcutRT::initialize() NOEXCEPT { + return 0; +} + +void ShortcutRT::terminate() NOEXCEPT {} + +size_t ShortcutRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +#if NV_TENSORRT_MAJOR > 7 +int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + shortcutForward(srcDataBack, dstData, batchSize, c, h, w, 1, batchSize, bc, bh, bw, 1, mul, stream); + + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ShortcutRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + shortcutForward(srcDataBack, dstData, batchSize, c, h, w, 1, batchSize, bc, bh, bw, 1, mul, stream); + + return 0; +} +#endif + + +size_t ShortcutRT::getSerializationSize() const NOEXCEPT { + return 6*sizeof(int) + sizeof(bool); +} + +void ShortcutRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, bc); + writeBUF(buf, bh); + writeBUF(buf, bw); + writeBUF(buf, mul); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool ShortcutRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ShortcutRT::getPluginType() const NOEXCEPT { + return SHORTCUTRT_PLUGIN_NAME; +} + +const char *ShortcutRT::getPluginVersion() const NOEXCEPT { + return SHORTCUTRT_PLUGIN_VERSION; +} + +void ShortcutRT::destroy() NOEXCEPT { + delete this; +} + +const char *ShortcutRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ShortcutRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ShortcutRT::clone() const NOEXCEPT { + auto *p = new ShortcutRT(bc,bh,bw,c,h,w,mul); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +void ShortcutRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +bool ShortcutRT::isOutputBroadcastAcrossBatch(int32_t outputIndex, const bool *inputIsBroadcasted, + int32_t nbInputs) const NOEXCEPT { + return false; +} + +bool ShortcutRT::canBroadcastInputAcrossBatch(int32_t inputIndex) const NOEXCEPT { + return false; +} + +void ShortcutRT::attachToContext(cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT { + +} + +void ShortcutRT::detachFromContext() NOEXCEPT { + +} + +DataType ShortcutRT::getOutputDataType(int32_t index, const nvinfer1::DataType *inputTypes, int32_t nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + + +ShortcutRTPluginCreator::ShortcutRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ShortcutRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ShortcutRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ShortcutRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ShortcutRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 7); + int bc = *(static_cast(fields[0].data)); + int bh = *(static_cast(fields[1].data)); + int bw = *(static_cast(fields[2].data)); + bool mul = *(static_cast(fields[3].data)); + int c = *(static_cast(fields[4].data)); + int h = *(static_cast(fields[5].data)); + int w = *(static_cast(fields[6].data)); + auto *pluginObj = new ShortcutRT(bc,bh,bw,c,h,w,mul); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ShortcutRTPluginCreator::getPluginName() const NOEXCEPT { + return SHORTCUTRT_PLUGIN_NAME; +} + +const char *ShortcutRTPluginCreator::getPluginVersion() const NOEXCEPT { + return SHORTCUTRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ShortcutRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp new file mode 100644 index 0000000..af21bc0 --- /dev/null +++ b/src/pluginsRT/UpsampleRT.cpp @@ -0,0 +1,197 @@ +#include +using namespace nvinfer1; + +std::vector UpsampleRTPluginCreator::mPluginAttributes; +PluginFieldCollection UpsampleRTPluginCreator::mFC{}; + +static const char* UPSAMPLERT_PLUGIN_VERSION{"1"}; +static const char* UPSAMPLERT_PLUGIN_NAME{"UpSample_tkDNN"}; + +UpsampleRT::UpsampleRT(int stride,int c,int h,int w) { + this->stride = stride; + this->h = h; + this->c = c; + this->w = w; +} + +UpsampleRT::UpsampleRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck=buf; + stride = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +UpsampleRT::~UpsampleRT() {} + +int UpsampleRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims UpsampleRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); +} + + + +int UpsampleRT::initialize() NOEXCEPT { + return 0; +} + +void UpsampleRT::terminate() NOEXCEPT {} + +size_t UpsampleRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int UpsampleRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + auto *srcData = (dnnType*)reinterpret_cast(inputs[0]); + auto *dstData = reinterpret_cast(outputs[0]); + + fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); + upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 +int32_t UpsampleRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); + upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); + return 0; +} +#endif + +size_t UpsampleRT::getSerializationSize() const NOEXCEPT { + return 4*sizeof(int); +} + +void UpsampleRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, stride); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool UpsampleRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *UpsampleRT::getPluginType() const NOEXCEPT { + return UPSAMPLERT_PLUGIN_NAME; +} + +const char *UpsampleRT::getPluginVersion() const NOEXCEPT { + return UPSAMPLERT_PLUGIN_VERSION; +} + +void UpsampleRT::destroy() NOEXCEPT { + delete this; +} + +const char *UpsampleRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void UpsampleRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *UpsampleRT::clone() const NOEXCEPT { + auto *p = new UpsampleRT(stride,c,h,w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +bool UpsampleRT::isOutputBroadcastAcrossBatch(int32_t outputIndex, const bool *inputIsBroadcasted, + int32_t nbInputs) const NOEXCEPT { + return false; +} + +bool UpsampleRT::canBroadcastInputAcrossBatch(int32_t inputIndex) const NOEXCEPT { + return false; +} + +void UpsampleRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +void UpsampleRT::attachToContext(cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT { +} + +void UpsampleRT::detachFromContext() NOEXCEPT { + +} + +DataType UpsampleRT::getOutputDataType(int32_t index, const nvinfer1::DataType *inputTypes, int32_t nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +UpsampleRTPluginCreator::UpsampleRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void UpsampleRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *UpsampleRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *UpsampleRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new UpsampleRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int stride = *(static_cast(fields[0].data)); + int c = *(static_cast(fields[1].data)); + int h = *(static_cast(fields[2].data)); + int w = *(static_cast(fields[3].data)); + auto *pluginObj = new UpsampleRT(stride,c,h,w); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *UpsampleRTPluginCreator::getPluginName() const NOEXCEPT { + return UPSAMPLERT_PLUGIN_NAME; +} + +const char *UpsampleRTPluginCreator::getPluginVersion() const NOEXCEPT { + return UPSAMPLERT_PLUGIN_VERSION; +} + +const PluginFieldCollection *UpsampleRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + + + diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp new file mode 100644 index 0000000..55cb462 --- /dev/null +++ b/src/pluginsRT/YoloRT.cpp @@ -0,0 +1,265 @@ +#include + +#include +using namespace nvinfer1; + +std::vector YoloRTPluginCreator::mPluginAttributes; +PluginFieldCollection YoloRTPluginCreator::mFC{}; + +static const char* YOLORT_PLUGIN_VERSION{"1"}; +static const char* YOLORT_PLUGIN_NAME{"YoloRT_tkDNN"}; + +YoloRT::YoloRT(int classes, int num, int c,int h,int w,int n_masks, float scale_xy, + float nms_thresh, int nms_kind, + int new_coords) { + this->c = c; + this->h = h; + this->w = w; + this->classes = classes; + this->num = num; + this->n_masks = n_masks; + this->scaleXY = scale_xy; + this->nms_thresh = nms_thresh; + this->nms_kind = nms_kind; + this->new_coords = new_coords; +} + +YoloRT::YoloRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + classes = readBUF(buf); + num = readBUF(buf); + n_masks = readBUF(buf); + scaleXY = readBUF(buf); + nms_thresh = readBUF(buf); + nms_kind = readBUF(buf); + new_coords = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +YoloRT::~YoloRT() {} + +int YoloRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims YoloRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + + + +int YoloRT::initialize() NOEXCEPT { + return 0; +} + +void YoloRT::terminate() NOEXCEPT {} + +size_t YoloRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int YoloRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda(cudaMemcpyAsync(dstData, srcData, batchSize * c * h * w * sizeof(dnnType), cudaMemcpyDeviceToDevice, + stream)); + + + for (int b = 0; b < batchSize; ++b) { + for (int n = 0; n < n_masks; ++n) { + int index = entry_index(b, n * w * h, 0); + if (new_coords == 1) { + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + } else { + activationLOGISTICForward(srcData + index, dstData + index, 2 * w * h, stream); //x,y + + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + + index = entry_index(b, n * w * h, 4); + activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); + } + } + } + + //std::cout<<"YOLO END\n"; + return 0; +} +#elif NV_TENSORRT_MAJOR == 7 +int32_t YoloRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda(cudaMemcpyAsync(dstData, srcData, batchSize * c * h * w * sizeof(dnnType), cudaMemcpyDeviceToDevice, + stream)); + + + for (int b = 0; b < batchSize; ++b) { + for (int n = 0; n < n_masks; ++n) { + int index = entry_index(b, n * w * h, 0); + if (new_coords == 1) { + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + } else { + activationLOGISTICForward(srcData + index, dstData + index, 2 * w * h, stream); //x,y + + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + + index = entry_index(b, n * w * h, 4); + activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); + } + } + } + + //std::cout<<"YOLO END\n"; + return 0; +} +#endif + + +size_t YoloRT::getSerializationSize() const NOEXCEPT { + return 8 * sizeof(int) + 2 * sizeof(float) ; +} + +bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +void YoloRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; + writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; + writeBUF(buf, n_masks); //std::cout << "N_Masks" << n_masks << std::endl; + writeBUF(buf, scaleXY); //std::cout << "ScaleXY :" << scaleXY << std::endl; + writeBUF(buf, nms_thresh); //std::cout << "nms_thresh :" << nms_thresh << std::endl; + writeBUF(buf, nms_kind); //std::cout << "nms_kind : " << nms_kind << std::endl; + writeBUF(buf, new_coords); //std::cout << "new_coords : " << new_coords << std::endl; + writeBUF(buf, c); //std::cout << "C : " << c << std::endl; + writeBUF(buf, h); //std::cout << "H : " << h << std::endl; + writeBUF(buf, w); //std::cout << "C : " << c << std::endl; + + assert(buf == a + getSerializationSize()); +} + +const char *YoloRT::getPluginType() const NOEXCEPT { + return YOLORT_PLUGIN_NAME; +} + +const char *YoloRT::getPluginVersion() const NOEXCEPT { + return YOLORT_PLUGIN_VERSION; +} + +void YoloRT::destroy() NOEXCEPT { + delete this; +} + +const char *YoloRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void YoloRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *YoloRT::clone() const NOEXCEPT { + auto *p = new YoloRT(classes, num,c,h,w,n_masks, scaleXY, nms_thresh, nms_kind, new_coords); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType YoloRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void YoloRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +void YoloRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +bool YoloRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool YoloRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void YoloRT::detachFromContext() NOEXCEPT { + +} + +YoloRTPluginCreator::YoloRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void YoloRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *YoloRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *YoloRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new YoloRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int classes = *(static_cast(fields[0].data)); + int num = *(static_cast(fields[1].data)); + int c = *(static_cast(fields[2].data)); + int h = *(static_cast(fields[3].data)); + int w = *(static_cast(fields[4].data)); + int n_masks = *(static_cast(fields[5].data)); + dnnType scaleXY = *(static_cast(fields[6].data)); + dnnType nmsThresh = *(static_cast(fields[7].data)); + int nms_kind = *(static_cast(fields[8].data)); + int new_coords = *(static_cast(fields[9].data)); + auto *pluginObj = new YoloRT(classes,num,c,h,w,n_masks,scaleXY,nmsThresh,nms_kind,new_coords); + return pluginObj; +} + +const char *YoloRTPluginCreator::getPluginName() const NOEXCEPT { + return YOLORT_PLUGIN_NAME; +} + +const char *YoloRTPluginCreator::getPluginVersion() const NOEXCEPT { + return YOLORT_PLUGIN_VERSION; +} + +const PluginFieldCollection *YoloRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/utils.cpp b/src/utils.cpp index 71dcce6..510b778 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -23,7 +23,7 @@ bool fileExist(const char *fname) { void downloadWeightsifDoNotExist(const std::string& input_bin, const std::string& test_folder, const std::string& weights_url){ if(!fileExist(input_bin.c_str())){ std::string mkdir_cmd = "mkdir " + test_folder; - std::string wget_cmd = "curl " + weights_url + " --output " + test_folder + "/weights.zip"; + std::string wget_cmd = "curl -tlsv1 -C - " + weights_url + " --output " + test_folder + "/weights.zip --user user:pass -O --retry 999 --retry-max-time 0"; #ifdef __linux__ std::string unzip_cmd = "unzip " + test_folder + "/weights.zip -d" + test_folder; std::string rm_cmd = "rm " + test_folder + "/weights.zip"; diff --git a/tests/centernet/dla34_cnet/dla34_cnet.cpp b/tests/centernet/dla34_cnet/dla34_cnet.cpp index 97a5b2a..303c30a 100644 --- a/tests/centernet/dla34_cnet/dla34_cnet.cpp +++ b/tests/centernet/dla34_cnet/dla34_cnet.cpp @@ -540,5 +540,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp b/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp index 939d4c5..3e6c02f 100644 --- a/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp +++ b/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp @@ -558,5 +558,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/centernet/resnet101_cnet/resnet101_cnet.cpp b/tests/centernet/resnet101_cnet/resnet101_cnet.cpp index 787422c..df1ae93 100644 --- a/tests/centernet/resnet101_cnet/resnet101_cnet.cpp +++ b/tests/centernet/resnet101_cnet/resnet101_cnet.cpp @@ -421,5 +421,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/darknet/csresnext50-panet-spp.cpp b/tests/darknet/csresnext50-panet-spp.cpp index a366e14..5413e52 100644 --- a/tests/darknet/csresnext50-panet-spp.cpp +++ b/tests/darknet/csresnext50-panet-spp.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/csresnext50-panet-spp_berkeley.cpp b/tests/darknet/csresnext50-panet-spp_berkeley.cpp index a8ba59f..1f52716 100644 --- a/tests/darknet/csresnext50-panet-spp_berkeley.cpp +++ b/tests/darknet/csresnext50-panet-spp_berkeley.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo2_voc.cpp b/tests/darknet/yolo2_voc.cpp index 94111e6..964c9f7 100644 --- a/tests/darknet/yolo2_voc.cpp +++ b/tests/darknet/yolo2_voc.cpp @@ -27,6 +27,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo2tiny.cpp b/tests/darknet/yolo2tiny.cpp index cc12109..f391a6f 100644 --- a/tests/darknet/yolo2tiny.cpp +++ b/tests/darknet/yolo2tiny.cpp @@ -28,6 +28,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3.cpp b/tests/darknet/yolo3.cpp index d9a684b..d61cf19 100644 --- a/tests/darknet/yolo3.cpp +++ b/tests/darknet/yolo3.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } \ No newline at end of file diff --git a/tests/darknet/yolo3_512.cpp b/tests/darknet/yolo3_512.cpp index c24550b..e4a6316 100644 --- a/tests/darknet/yolo3_512.cpp +++ b/tests/darknet/yolo3_512.cpp @@ -41,6 +41,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3_berkeley.cpp b/tests/darknet/yolo3_berkeley.cpp index 016a8a2..620692a 100644 --- a/tests/darknet/yolo3_berkeley.cpp +++ b/tests/darknet/yolo3_berkeley.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3_coco4.cpp b/tests/darknet/yolo3_coco4.cpp index eaf9bd8..89a1616 100644 --- a/tests/darknet/yolo3_coco4.cpp +++ b/tests/darknet/yolo3_coco4.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3_flir.cpp b/tests/darknet/yolo3_flir.cpp index 24aac7f..557a4ca 100644 --- a/tests/darknet/yolo3_flir.cpp +++ b/tests/darknet/yolo3_flir.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3tiny.cpp b/tests/darknet/yolo3tiny.cpp index c33f7a8..c18a60c 100644 --- a/tests/darknet/yolo3tiny.cpp +++ b/tests/darknet/yolo3tiny.cpp @@ -28,6 +28,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3tiny_512.cpp b/tests/darknet/yolo3tiny_512.cpp index 8460416..f8aae61 100644 --- a/tests/darknet/yolo3tiny_512.cpp +++ b/tests/darknet/yolo3tiny_512.cpp @@ -41,6 +41,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4-csp.cpp b/tests/darknet/yolo4-csp.cpp index 8ad8aef..f354a48 100644 --- a/tests/darknet/yolo4-csp.cpp +++ b/tests/darknet/yolo4-csp.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } \ No newline at end of file diff --git a/tests/darknet/yolo4.cpp b/tests/darknet/yolo4.cpp index 8de8651..08e10a9 100644 --- a/tests/darknet/yolo4.cpp +++ b/tests/darknet/yolo4.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_320.cpp b/tests/darknet/yolo4_320.cpp index 0e623e0..db03024 100644 --- a/tests/darknet/yolo4_320.cpp +++ b/tests/darknet/yolo4_320.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_320_coco2.cpp b/tests/darknet/yolo4_320_coco2.cpp index 877e604..b8fd3bf 100644 --- a/tests/darknet/yolo4_320_coco2.cpp +++ b/tests/darknet/yolo4_320_coco2.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_512.cpp b/tests/darknet/yolo4_512.cpp index 9d4c389..b5e3975 100644 --- a/tests/darknet/yolo4_512.cpp +++ b/tests/darknet/yolo4_512.cpp @@ -42,6 +42,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_608.cpp b/tests/darknet/yolo4_608.cpp index dda084f..762f83a 100644 --- a/tests/darknet/yolo4_608.cpp +++ b/tests/darknet/yolo4_608.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_berkeley.cpp b/tests/darknet/yolo4_berkeley.cpp index 89e9f04..70dee4b 100644 --- a/tests/darknet/yolo4_berkeley.cpp +++ b/tests/darknet/yolo4_berkeley.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_berkeley_f1.cpp b/tests/darknet/yolo4_berkeley_f1.cpp index b2f1139..7d830c3 100644 --- a/tests/darknet/yolo4_berkeley_f1.cpp +++ b/tests/darknet/yolo4_berkeley_f1.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_mmr.cpp b/tests/darknet/yolo4_mmr.cpp index 85649b2..e22f662 100644 --- a/tests/darknet/yolo4_mmr.cpp +++ b/tests/darknet/yolo4_mmr.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4tiny.cpp b/tests/darknet/yolo4tiny.cpp index 44fbac8..225433c 100644 --- a/tests/darknet/yolo4tiny.cpp +++ b/tests/darknet/yolo4tiny.cpp @@ -26,8 +26,10 @@ int main() { tk::dnn::NetworkRT *netRT = new tk::dnn::NetworkRT(net, net->getNetworkRTName(bin_path.c_str())); int ret = testInference(input_bins, output_bins, net, netRT); + std::cout<releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4tiny_512.cpp b/tests/darknet/yolo4tiny_512.cpp index fd15aea..1b53ed3 100644 --- a/tests/darknet/yolo4tiny_512.cpp +++ b/tests/darknet/yolo4tiny_512.cpp @@ -40,6 +40,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4x.cpp b/tests/darknet/yolo4x.cpp index 8df1aef..7f793f7 100644 --- a/tests/darknet/yolo4x.cpp +++ b/tests/darknet/yolo4x.cpp @@ -31,6 +31,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/mnist/test_mnistRT.cpp b/tests/mnist/test_mnistRT.cpp index 1b4e9c3..2f6b7c4 100644 --- a/tests/mnist/test_mnistRT.cpp +++ b/tests/mnist/test_mnistRT.cpp @@ -15,7 +15,7 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { - void log(Severity severity, const char* msg) override + void log(Severity severity, const char* msg) NOEXCEPT override { // suppress info-level messages if (severity != Severity::kINFO) @@ -66,11 +66,11 @@ int main() { std::cout<<"\n==== TensorRT ====\n"; // create the builder IBuilder* builder = nvinfer1::createInferBuilder(gLogger); - INetworkDefinition* network = builder->createNetwork(); - + IBuilderConfig* config = builder->createBuilderConfig(); + INetworkDefinition* network = builder->createNetworkV2(0U); DataType dt = DataType::kFLOAT; // Create input of shape { 1, 1, 28, 28 } with name referenced by "data" - auto input = network->addInput("data", dt, DimsCHW{ 1, 28, 28}); + auto input = network->addInput("data", dt, Dims3{ 1, 28, 28}); assert(input != nullptr); tk::dnn::Conv2d *c0 = &l0; @@ -126,9 +126,9 @@ int main() { // Build the engine builder->setMaxBatchSize(1); - builder->setMaxWorkspaceSize(1 << 20); + config->setMaxWorkspaceSize(1 << 20); - auto engine = builder->buildCudaEngine(*network); + auto engine = builder->buildEngineWithConfig(*network,*config); // we don't need the network any more network->destroy(); diff --git a/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp b/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp index c3c6472..46064de 100644 --- a/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp +++ b/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp @@ -542,5 +542,6 @@ int main() ret_cudnn_tensorrt |= checkResult(conf->output_dim.tot(), conf->dstData, rt_out3) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; ret_cudnn_tensorrt |= checkResult(loc->output_dim.tot(), loc->dstData, rt_out4) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp b/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp index 58463a4..e10737e 100644 --- a/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp +++ b/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp @@ -541,6 +541,6 @@ int main() std::cout << "CUDNN vs TRT " << std::endl; ret_cudnn_tensorrt |= checkResult(conf->output_dim.tot(), conf->dstData, rt_out3) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; ret_cudnn_tensorrt |= checkResult(loc->output_dim.tot(), loc->dstData, rt_out4) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp b/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp index 0a817c1..b6c8593 100644 --- a/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp +++ b/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp @@ -553,6 +553,6 @@ int main() std::cout << "CUDNN vs TRT " << std::endl; ret_cudnn_tensorrt |= checkResult(conf->output_dim.tot(), conf->dstData, rt_out3) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; ret_cudnn_tensorrt |= checkResult(loc->output_dim.tot(), loc->dstData, rt_out4) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/monodepth2/monodepth2_1024.cpp b/tests/monodepth2/monodepth2_1024.cpp new file mode 100644 index 0000000..0dc7c0d --- /dev/null +++ b/tests/monodepth2/monodepth2_1024.cpp @@ -0,0 +1,266 @@ +#include +#include +#include +#include +#include +#include "tkDNN/NetworkViz.h" + +const char* encoder_conv1_bin = "monodepth2_1024/layers/encoder/encoder-conv1.bin"; +const char* encoder_layer1_bin[] = { + "monodepth2_1024/layers/encoder/encoder-layer1-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer1-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer1-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer1-1-conv2.bin", +}; + +const char* encoder_layer2_bin[] = { + "monodepth2_1024/layers/encoder/encoder-layer2-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-0-downsample-0.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-1-conv2.bin" +}; + +const char* encoder_layer3_bin[]={ + "monodepth2_1024/layers/encoder/encoder-layer3-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-0-downsample-0.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-1-conv2.bin" +}; + +const char* encoder_layer4_bin[] = { + "monodepth2_1024/layers/encoder/encoder-layer4-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-0-downsample-0.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-1-conv2.bin" +}; + +const char *encoder_fc_bin = "monodepth2_1024/layers/encoder/encoder-fc.bin"; + +const char* decoder_layer_bin[] = { + "monodepth2_1024/layers/depth_decoder/decoder-0-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-1-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-2-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-3-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-4-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-5-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-6-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-7-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-8-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-9-conv-conv.bin" +}; + +const char* decoder_dispconv_layer_bin[] = { + "monodepth2_1024/layers/depth_decoder/decoder-10-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-11-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-12-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-13-conv.bin" +}; + +const char* output_bin[] = { + "monodepth2_1024/debug/outputs/output-disp-0.bin", + "monodepth2_1024/debug/outputs/output-disp-1.bin", + "monodepth2_1024/debug/outputs/output-disp-2.bin", + "monodepth2_1024/debug/outputs/output-disp-3.bin" +}; + +const char* input_bin = "monodepth2_1024/debug/input.bin"; + + +int main(){ + + //downloadWeightsifDoNotExist(input_bin, "monodepth2_1024", "https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download"); + + tk::dnn::dataDim_t dim(1,3,320,1024,1); + tk::dnn::Network net(dim); + + tk::dnn::Layer* muladd_sub = new tk::dnn::MulAdd(&net, 1.0f, -0.45f); + tk::dnn::Layer* muladd_mul = new tk::dnn::MulAdd(&net, 1.0f / 0.225f, 0.0f); + tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin,true); + tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); + + //layer-1 + tk::dnn::Layer* encoder_layer_1_0_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[0],true); + tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_0_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[1],true); + tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); + tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[2],true); + tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[3],true); + tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); + tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-2 + tk::dnn::Layer* encoder_layer_2_0_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true); + tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_0_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true); + tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); + tk::dnn::Layer* encoder_layer_2_0_downsample_convbn = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2],true); + tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_convbn_2); + tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true); + tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true); + tk::dnn::Layer* encoder_layer_2_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); + tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-3 + tk::dnn::Layer* encoder_layer_3_0_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true); + tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_0_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true); + tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); + tk::dnn::Layer* encoder_layer_3_0_downsample_convbn = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2],true); + tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_convbn_2); + tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true); + tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true); + tk::dnn::Layer* encoder_layer_3_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); + tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-4 + tk::dnn::Layer* encoder_layer_4_0_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true); + tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_0_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true); + tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); + tk::dnn::Layer* encoder_layer_4_0_downsample_convbn = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2],true); + tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_convbn_2); + tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true); + tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true); + tk::dnn::Layer* encoder_layer_4_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); + tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //decoder + tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); + tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; + tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); + tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); + tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); + tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; + tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; + tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); + tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); + tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; + tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); + tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); + tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); + tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; + tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); + tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); + tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); + tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); + tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); + tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp0->setFinal(); + + tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); + tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); + tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp1->setFinal(); + + tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); + tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); + tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp2->setFinal(); + + tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); + tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); + tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp3->setFinal(); + + + dnnType *data; + dnnType *input_H; + readBinaryFile(input_bin, dim.tot(),&input_H,&data); + std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + for(int i=0;i<4;i++){ + printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); + outs[i]->output_dim.print(); + + dnnType *out, *out_h; + int odim = outs[i]->output_dim.tot(); + readBinaryFile(output_bin[i], odim, &out_h, &out); + + dnnType *cudnn_out, *rt_out; + cudnn_out = outs[i]->dstData; + rt_out = (dnnType *)netRT.buffersRT[1+i]; + std::cout<<"CUDNN vs correct"; + ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; + std::cout<<"TRT vs correct"; + ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; + std::cout<<"CUDNN vs TRT "; + ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + + cv::Mat depth_mat = vizData2Mat(outs[i]->dstData, outs[i]->output_dim, outs[i]->output_dim.h, outs[i]->output_dim.w); + cv::imshow("depth", depth_mat); + cv::waitKey(0); + } + + + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; + + +} \ No newline at end of file diff --git a/tests/monodepth2/monodepth2_640.cpp b/tests/monodepth2/monodepth2_640.cpp new file mode 100644 index 0000000..378c735 --- /dev/null +++ b/tests/monodepth2/monodepth2_640.cpp @@ -0,0 +1,266 @@ +#include +#include +#include +#include +#include +#include "tkDNN/NetworkViz.h" + +const char* encoder_conv1_bin = "monodepth2_640/layers/encoder/encoder-conv1.bin"; +const char* encoder_layer1_bin[] = { + "monodepth2_640/layers/encoder/encoder-layer1-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer1-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer1-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer1-1-conv2.bin", +}; + +const char* encoder_layer2_bin[] = { + "monodepth2_640/layers/encoder/encoder-layer2-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer2-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer2-0-downsample-0.bin", + "monodepth2_640/layers/encoder/encoder-layer2-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer2-1-conv2.bin" +}; + +const char* encoder_layer3_bin[]={ + "monodepth2_640/layers/encoder/encoder-layer3-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer3-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer3-0-downsample-0.bin", + "monodepth2_640/layers/encoder/encoder-layer3-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer3-1-conv2.bin" +}; + +const char* encoder_layer4_bin[] = { + "monodepth2_640/layers/encoder/encoder-layer4-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer4-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer4-0-downsample-0.bin", + "monodepth2_640/layers/encoder/encoder-layer4-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer4-1-conv2.bin" +}; + +const char *encoder_fc_bin = "monodepth2_640/layers/encoder/encoder-fc.bin"; + +const char* decoder_layer_bin[] = { + "monodepth2_640/layers/depth_decoder/decoder-0-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-1-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-2-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-3-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-4-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-5-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-6-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-7-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-8-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-9-conv-conv.bin" +}; + +const char* decoder_dispconv_layer_bin[] = { + "monodepth2_640/layers/depth_decoder/decoder-10-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-11-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-12-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-13-conv.bin" +}; + +const char* output_bin[] = { + "monodepth2_640/debug/outputs/output-disp-0.bin", + "monodepth2_640/debug/outputs/output-disp-1.bin", + "monodepth2_640/debug/outputs/output-disp-2.bin", + "monodepth2_640/debug/outputs/output-disp-3.bin" +}; + +const char* input_bin = "monodepth2_640/debug/input.bin"; + + +int main(){ + + downloadWeightsifDoNotExist(input_bin, "monodepth2_640", "https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download"); + + tk::dnn::dataDim_t dim(1,3,192,640,1); + tk::dnn::Network net(dim); + + tk::dnn::Layer* muladd_sub = new tk::dnn::MulAdd(&net, 1.0f, -0.45f); + tk::dnn::Layer* muladd_mul = new tk::dnn::MulAdd(&net, 1.0f / 0.225f, 0.0f); + tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin,true); + tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); + + //layer-1 + tk::dnn::Layer* encoder_layer_1_0_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[0],true); + tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_0_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[1],true); + tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); + tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[2],true); + tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[3],true); + tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); + tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-2 + tk::dnn::Layer* encoder_layer_2_0_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true); + tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_0_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true); + tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); + tk::dnn::Layer* encoder_layer_2_0_downsample_convbn = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2],true); + tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_convbn_2); + tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true); + tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true); + tk::dnn::Layer* encoder_layer_2_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); + tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-3 + tk::dnn::Layer* encoder_layer_3_0_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true); + tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_0_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true); + tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); + tk::dnn::Layer* encoder_layer_3_0_downsample_convbn = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2],true); + tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_convbn_2); + tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true); + tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true); + tk::dnn::Layer* encoder_layer_3_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); + tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-4 + tk::dnn::Layer* encoder_layer_4_0_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true); + tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_0_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true); + tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); + tk::dnn::Layer* encoder_layer_4_0_downsample_convbn = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2],true); + tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_convbn_2); + tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true); + tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true); + tk::dnn::Layer* encoder_layer_4_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); + tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //decoder + tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); + tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; + tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); + tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); + tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); + tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; + tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; + tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); + tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); + tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; + tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); + tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); + tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); + tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; + tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); + tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); + tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); + tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); + tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); + tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp0->setFinal(); + + tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); + tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); + tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp1->setFinal(); + + tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); + tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); + tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp2->setFinal(); + + tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); + tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); + tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp3->setFinal(); + + + dnnType *data; + dnnType *input_H; + readBinaryFile(input_bin, dim.tot(),&input_H,&data); + std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + for(int i=0;i<4;i++){ + printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); + outs[i]->output_dim.print(); + + dnnType *out, *out_h; + int odim = outs[i]->output_dim.tot(); + readBinaryFile(output_bin[i], odim, &out_h, &out); + + dnnType *cudnn_out, *rt_out; + cudnn_out = outs[i]->dstData; + rt_out = (dnnType *)netRT.buffersRT[1+i]; + std::cout<<"CUDNN vs correct"; + ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; + std::cout<<"TRT vs correct"; + ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; + std::cout<<"CUDNN vs TRT "; + ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + + cv::Mat depth_mat = vizData2Mat(outs[i]->dstData, outs[i]->output_dim, outs[i]->output_dim.h, outs[i]->output_dim.w); + cv::imshow("depth", depth_mat); + cv::waitKey(0); + } + + + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; + + +} \ No newline at end of file diff --git a/tests/shelfnet/shelfnet.cpp b/tests/shelfnet/shelfnet.cpp index 48cad04..07c7f6e 100644 --- a/tests/shelfnet/shelfnet.cpp +++ b/tests/shelfnet/shelfnet.cpp @@ -290,6 +290,6 @@ int main() cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/shelfnet/shelfnet_berkeley.cpp b/tests/shelfnet/shelfnet_berkeley.cpp index 5ee21df..88f16a5 100644 --- a/tests/shelfnet/shelfnet_berkeley.cpp +++ b/tests/shelfnet/shelfnet_berkeley.cpp @@ -9,77 +9,77 @@ const char *input_bin = "shelfnet_berkeley/debug/input.bin"; const char *backbone[] = { - "shelfnet_berkeley/layers/backbone-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer1-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer1-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer1-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer1-1-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer2-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer2-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer2-0-downsample-0.bin", - "shelfnet_berkeley/layers/backbone-layer2-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer2-1-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer3-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer3-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer3-0-downsample-0.bin", - "shelfnet_berkeley/layers/backbone-layer3-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer3-1-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer4-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer4-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer4-0-downsample-0.bin", - "shelfnet_berkeley/layers/backbone-layer4-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer4-1-conv2.bin"}; + "shelfnet_berkeley/layers/backbone-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer1-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer1-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer1-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer1-1-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer2-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer2-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer2-0-downsample-0.bin", + "shelfnet_berkeley/layers/backbone-layer2-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer2-1-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer3-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer3-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer3-0-downsample-0.bin", + "shelfnet_berkeley/layers/backbone-layer3-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer3-1-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer4-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer4-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer4-0-downsample-0.bin", + "shelfnet_berkeley/layers/backbone-layer4-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer4-1-conv2.bin"}; const char *conv_out[] = { - "shelfnet_berkeley/layers/conv_out-conv-conv.bin", - "shelfnet_berkeley/layers/conv_out-conv_out.bin", - "shelfnet_berkeley/layers/conv_out16-conv-conv.bin", - "shelfnet_berkeley/layers/conv_out16-conv_out.bin", - "shelfnet_berkeley/layers/conv_out32-conv-conv.bin", - "shelfnet_berkeley/layers/conv_out32-conv_out.bin" - }; + "shelfnet_berkeley/layers/conv_out-conv-conv.bin", + "shelfnet_berkeley/layers/conv_out-conv_out.bin", + "shelfnet_berkeley/layers/conv_out16-conv-conv.bin", + "shelfnet_berkeley/layers/conv_out16-conv_out.bin", + "shelfnet_berkeley/layers/conv_out32-conv-conv.bin", + "shelfnet_berkeley/layers/conv_out32-conv_out.bin" +}; const char *decoder[] = { - "shelfnet_berkeley/layers/decoder-bottom-conv1.bin", - "shelfnet_berkeley/layers/decoder-bottom-conv12.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv-conv.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv_atten.bin", - "shelfnet_berkeley/layers/decoder-up_dense_list-0-conv.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv-conv.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv_atten.bin", - "shelfnet_berkeley/layers/decoder-up_dense_list-1-conv.bin" - }; + "shelfnet_berkeley/layers/decoder-bottom-conv1.bin", + "shelfnet_berkeley/layers/decoder-bottom-conv12.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv-conv.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv_atten.bin", + "shelfnet_berkeley/layers/decoder-up_dense_list-0-conv.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv-conv.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv_atten.bin", + "shelfnet_berkeley/layers/decoder-up_dense_list-1-conv.bin" +}; + - const char *ladder[] = { - "shelfnet_berkeley/layers/ladder-inconv-conv1.bin", - "shelfnet_berkeley/layers/ladder-inconv-conv12.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-0-conv1.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-0-conv12.bin", - "shelfnet_berkeley/layers/ladder-down_conv_list-0.bin", + "shelfnet_berkeley/layers/ladder-inconv-conv1.bin", + "shelfnet_berkeley/layers/ladder-inconv-conv12.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-0-conv1.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-0-conv12.bin", + "shelfnet_berkeley/layers/ladder-down_conv_list-0.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-1-conv1.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-1-conv12.bin", - "shelfnet_berkeley/layers/ladder-down_conv_list-1.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-1-conv1.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-1-conv12.bin", + "shelfnet_berkeley/layers/ladder-down_conv_list-1.bin", - "shelfnet_berkeley/layers/ladder-bottom-conv1.bin", - "shelfnet_berkeley/layers/ladder-bottom-conv12.bin", - - - - "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv-conv.bin", - "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv_atten.bin", - "shelfnet_berkeley/layers/ladder-up_dense_list-0-conv.bin", + "shelfnet_berkeley/layers/ladder-bottom-conv1.bin", + "shelfnet_berkeley/layers/ladder-bottom-conv12.bin", - - "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv-conv.bin", - "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv_atten.bin", - "shelfnet_berkeley/layers/ladder-up_dense_list-1-conv.bin"}; + + + "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv-conv.bin", + "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv_atten.bin", + "shelfnet_berkeley/layers/ladder-up_dense_list-0-conv.bin", + + + "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv-conv.bin", + "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv_atten.bin", + "shelfnet_berkeley/layers/ladder-up_dense_list-1-conv.bin"}; const char *trans[] = { - "shelfnet_berkeley/layers/trans1-conv.bin", - "shelfnet_berkeley/layers/trans2-conv.bin", - "shelfnet_berkeley/layers/trans3-conv.bin"}; + "shelfnet_berkeley/layers/trans1-conv.bin", + "shelfnet_berkeley/layers/trans2-conv.bin", + "shelfnet_berkeley/layers/trans3-conv.bin"}; int main() { @@ -87,7 +87,7 @@ int main() int classes = 20; - // Network layout + // Network layout tk::dnn::dataDim_t dim(1, 3, 736, 1280, 1); tk::dnn::Network net(dim); @@ -97,7 +97,7 @@ int main() tk::dnn::Layer* last = new tk::dnn::Pooling (&net, 3, 3, 2, 2, 1, 1, tk::dnn::POOLING_MAX); - + for(int i=0; i<2; ++i){ new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, backbone[bi++], true); new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); @@ -121,7 +121,7 @@ int main() new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, backbone[bi++], true); new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, backbone[bi++], true); - + new tk::dnn::Shortcut(&net, last); last = new tk::dnn::Activation (&net, CUDNN_ACTIVATION_RELU); features.push_back(last); @@ -135,7 +135,7 @@ int main() } //DECODER - + last = features[2]; std::vector up_out; //bottom @@ -152,10 +152,10 @@ int main() std::cout<output_dim.w, last->output_dim.h, last->output_dim.w, last->output_dim.h, 0, 0, tk::dnn::POOLING_AVERAGE); new tk::dnn::Conv2d (&net, out_channel, 1, 1, 1, 1, 0, 0, decoder[di++], true); - + tk::dnn::Layer* act = new tk::dnn::Activation (&net, CUDNN_ACTIVATION_SIGMOID); new tk::dnn::Route(&net, &last, 1); new tk::dnn::Shortcut(&net, act, true); @@ -178,11 +178,11 @@ int main() new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, ladder[li++], true, false, 1, true); new tk::dnn::Shortcut(&net, last); new tk::dnn::Activation (&net, CUDNN_ACTIVATION_RELU); - + for(int i=0; i<2;++i){ int out_channel = pow(2,6+i); tk::dnn::Layer* l_last = new tk::dnn::Shortcut(&net, up_out[2-i]); - + new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, ladder[li++], true, false, 1, true); new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, ladder[li++], true, false, 1, true); @@ -207,10 +207,10 @@ int main() //up-conv new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, ladder[li++], true); last = new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); - + new tk::dnn::Pooling(&net, last->output_dim.w, last->output_dim.h, last->output_dim.w, last->output_dim.h, 0, 0, tk::dnn::POOLING_AVERAGE); new tk::dnn::Conv2d (&net, out_channel, 1, 1, 1, 1, 0, 0, ladder[li++], true); - + tk::dnn::Layer* act = new tk::dnn::Activation (&net, CUDNN_ACTIVATION_SIGMOID); new tk::dnn::Route(&net, &last, 1); new tk::dnn::Shortcut(&net, act, true); @@ -227,17 +227,17 @@ int main() // for(int i=2;i>=0;--i){ - // new tk::dnn::Route(&net, &up_out[i], 1); - new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, conv_out[ci++], true); - new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); - new tk::dnn::Conv2d (&net, classes, 3, 3, 1, 1, 1, 1, conv_out[ci++], false); - /*up_out[i] =*/ new tk::dnn::Resize(&net, classes, net.input_dim.h, net.input_dim.w, true, tk::dnn::ResizeMode_t::LINEAR); + // new tk::dnn::Route(&net, &up_out[i], 1); + new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, conv_out[ci++], true); + new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); + new tk::dnn::Conv2d (&net, classes, 3, 3, 1, 1, 1, 1, conv_out[ci++], false); + /*up_out[i] =*/ new tk::dnn::Resize(&net, classes, net.input_dim.h, net.input_dim.w, true, tk::dnn::ResizeMode_t::LINEAR); // } new tk::dnn::Softmax(&net); - + const char *output_bin = "shelfnet_berkeley/debug/softmax.bin"; - + // Load input dnnType *data; dnnType *input_h; @@ -278,7 +278,7 @@ int main() int odim1 = dim1.tot(); readBinaryFile(output_bin, odim1, &out1_h, &out1); - int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; std::cout << "CUDNN vs correct" << std::endl; ret_cudnn |= checkResult(odim1, cudnn_out, out1, true, 20) == 0 ? 0 : ERROR_CUDNN; @@ -287,9 +287,9 @@ int main() std::cout << "CUDNN vs TRT " << std::endl; ret_cudnn_tensorrt |= checkResult(odim1, cudnn_out, rt_out1) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - + cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; -} +} \ No newline at end of file diff --git a/tests/shelfnet/shelfnet_mapillary.cpp b/tests/shelfnet/shelfnet_mapillary.cpp index fd92305..6c8b0ce 100644 --- a/tests/shelfnet/shelfnet_mapillary.cpp +++ b/tests/shelfnet/shelfnet_mapillary.cpp @@ -292,6 +292,6 @@ int main() cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; }