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 b366416..7cc9e33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,15 +1,65 @@ 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++11 -fPIC -Wno-deprecated-declarations -Wno-unused-variable ") +set(CMAKE_CXX_STANDARD 14) + +option(ENABLE_OPENCV_CUDA_CONTRIB "Enable OpenCV CUDA Contrib" OFF ) + +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) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") + 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 +68,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 +78,20 @@ 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) + find_package(CUDNN REQUIRED) include_directories(${CUDNN_INCLUDE_DIR}) # 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}) + #------------------------------------------------------------------------------- @@ -53,6 +103,18 @@ 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() @@ -69,7 +131,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}) @@ -168,7 +230,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 b630fec..d07ac42 100644 --- a/README.md +++ b/README.md @@ -17,10 +17,9 @@ If you use tkDNN in your research, please cite the [following paper](https://iee } ``` -### What's new (20 July 2021) -- [x] Support to sematic segmentation [README](docs/README_seg.md) -- [x] Support 2D/3D Object Detection and Tracking [README](docs/README_2d3dtracking.md) -- [ ] Support to TensorRT8 (WIP) +### What's new (November 2021) +- [x] Support to sematic segmentation on cuda 11+ [README](docs/README_seg.md) +- [x] Support to TensorRT8 ## FPS Results Inference FPS of yolov4 with tkDNN, average of 1200 images with the same dimension as the input size, on @@ -75,17 +74,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) [the segmentation only works with CUDA 10 for now] +* 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 @@ -101,17 +100,19 @@ 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 .. -make +cmake -DCMAKE_BUILD_TYPE=Release -G"Ninja" .. +ninja ``` ## Workflow @@ -136,9 +137,9 @@ For specific details on how to run: ![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 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 317a574..b1cf574 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -18,46 +18,60 @@ void sig_handler(int signo) { int main(int argc, char *argv[]) { - std::cout<<"detection\n"; signal(SIGINT, sig_handler); +#ifdef __linux__ + std::string config_file = "../demo/demoConfig.yaml"; +#elif _WIN32 + std::string config_file = "..\\..\\..\\demo\\demoConfig.yaml"; +#endif - std::string net = "yolo4tiny_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 > 1){ + config_file = argv[1]; + } - if(argc > 2) - input = argv[2]; - char ntype = 'y'; - if(argc > 3) - ntype = argv[3][0]; - int n_classes = 80; - if(argc > 4) - n_classes = atoi(argv[4]); - int n_batch = 1; - if(argc > 5) - n_batch = atoi(argv[5]); - bool show = true; - if(argc > 6) - show = atoi(argv[6]); - float conf_thresh=0.3; - if(argc > 7) - conf_thresh = atof(argv[7]); + YAML::Node conf = YAMLloadConf(config_file); + if(!conf){ + FatalError("Problem with config file"); + } + + std::string net = YAMLgetConf(conf,"net","yolo4tiny_fp32.rt"); + if(!fileExist(net.c_str())) { + FatalError("The given network does not exist. Create the rt first."); + } + +#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 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())) + 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); if(n_batch < 1 || n_batch > 64) - FatalError("Batch dim not supported"); + FatalError("Batch dim not supported"); + float conf_thresh = YAMLgetConf(conf, "conf_thresh", 0.3); + bool show = YAMLgetConf(conf, "show", true); + bool save = YAMLgetConf(conf, "save", false); + + + + + + - if(!show) - SAVE_RESULT = true; tk::dnn::Yolo3Detection yolo; tk::dnn::CenternetDetection cnet; - tk::dnn::MobilenetDetection mbnet; + tk::dnn::MobilenetDetection mbnet; tk::dnn::DetectionNN *detNN; @@ -77,7 +91,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); gRun = true; @@ -88,7 +107,7 @@ int main(int argc, char *argv[]) { std::cout<<"camera started\n"; cv::VideoWriter resultVideo; - if(SAVE_RESULT) { + if(save) { int w = cap.get(cv::CAP_PROP_FRAME_WIDTH); int h = cap.get(cv::CAP_PROP_FRAME_HEIGHT); resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','P','4','V'), 30, cv::Size(w, h)); @@ -128,7 +147,7 @@ int main(int argc, char *argv[]) { cv::waitKey(1); } } - if(n_batch == 1 && SAVE_RESULT) + if(n_batch == 1 && save) resultVideo << frame; } @@ -136,7 +155,7 @@ int main(int argc, char *argv[]) { double mean = 0; std::cout<stats.begin(), detNN->stats.end())/n_batch<<" ms\n"; + std::cout<<"Min: "<<*std::min_element(detNN->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"; for(int i=0; istats.size(); i++) mean += detNN->stats[i]; mean /= detNN->stats.size(); std::cout<<"Avg: "< 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 new file mode 100644 index 0000000..f14ffaa --- /dev/null +++ b/demo/demoConfig.yaml @@ -0,0 +1,22 @@ +# video input +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' +n_classes : 80 +n_batch : 1 +conf_thresh : 0.3 + +# demo config +show : true +save : false \ No newline at end of file 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/demo.md b/docs/demo.md index cc93dd4..bf6b79d 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -26,27 +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 yolo4_fp32.rt ../demo/yolo_test.mp4 y +./ demo ``` -In general the demo program takes 7 parameters: -``` -./demo -``` -where +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"```. -* `````` is the rt file generated by a test -* ```<``` is the path to a video file or a camera input -* `````` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) -* ``````is the number of classes the network is trained on -* `````` 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). -* `````` if set to 0 the demo will not show the visualization but save the video into result.mp4 (if n-batches ==1) -* `````` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. +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) +* ```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 @@ -59,9 +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) -./demo yolo3_fp16.rt ../demo/yolo_test.mp4 y +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,9 +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) -./demo yolo3_int8.rt ../demo/yolo_test.mp4 y +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/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/DetectionNN.h b/include/tkDNN/DetectionNN.h index a8c81f7..3a757ef 100644 --- a/include/tkDNN/DetectionNN.h +++ b/include/tkDNN/DetectionNN.h @@ -87,7 +87,7 @@ class DetectionNN { * @param n_batches maximum number of batches to use in inference * @return true if everything is correct, false otherwise. */ - virtual bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3) = 0; + virtual 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) = 0; /** * This method performs the whole detection of the NN. diff --git a/include/tkDNN/Int8BatchStream.h b/include/tkDNN/Int8BatchStream.h index c39a11c..028f75d 100644 --- a/include/tkDNN/Int8BatchStream.h +++ b/include/tkDNN/Int8BatchStream.h @@ -39,7 +39,7 @@ public: float *getLabels() { return mLabels.data(); } int getBatchesRead() const { return mBatchCount; } int getBatchSize() const { return mBatchSize; } - nvinfer1::DimsNCHW getDims() const { return mDims; } + nvinfer1::Dims4 getDims() const { return mDims; } float* getFileBatch() { return &mFileBatch[0]; } float* getFileLabels() { return &mFileLabels[0]; } void readInListFile(const std::string& dataFilePath, std::vector& 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..5273c83 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -56,8 +56,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; @@ -423,6 +423,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 +438,7 @@ public: virtual layerType_t getLayerType() { return LAYER_RESHAPE; }; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int n,c,h,w; }; @@ -497,6 +500,7 @@ public: int winH, winW; int strideH, strideW; int paddingH, paddingW; + int padding; bool size; tkdnnPoolingMode_t pool_mode; @@ -582,6 +586,8 @@ public: virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int c,h,w; + public: Layer *backLayer; bool mul = false; @@ -602,6 +608,7 @@ public: int stride; bool reverse; + int c,h,w; }; struct box { @@ -685,6 +692,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..cd9f649 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -7,47 +7,28 @@ #include "Layer.h" #include "NvInfer.h" #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 +50,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 +86,24 @@ 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::ILayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Yolo *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *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/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index b691cbc..403bc28 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; } 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/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/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..02ff596 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,81 +1,96 @@ #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); +}; \ 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/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 65375ba..a1a1f1c 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -6,24 +6,48 @@ #include #include #include +#include + #include "cuda.h" #include "cuda_runtime_api.h" #include #include +#include #ifdef __linux__ #include - #endif #include #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" @@ -137,4 +161,20 @@ static inline bool isCudaPointer(void *data) { cudaPointerAttributes attr; return cudaPointerGetAttributes(&attr, data) == 0; } + +inline YAML::Node YAMLloadConf(const std::string& conf_file) { + std::cerr<<"Loading YAML: "< +inline T YAMLgetConf(YAML::Node conf, std::string key, T defaultVal) { + T val = defaultVal; + if(conf && conf[key]) { + val = conf[key].as(); + } + return val; +} + + #endif //UTILS_H diff --git a/scripts/checkExecTimes.py b/scripts/checkExecTimes.py new file mode 100644 index 0000000..c3e1b0b --- /dev/null +++ b/scripts/checkExecTimes.py @@ -0,0 +1,37 @@ +import sys +import pandas as pd + +if len(sys.argv) < 3: + print("Error: two csv files are needed, old first new second") + exit(1) + +old_perf_file = str(sys.argv[1]) +new_perf_file = str(sys.argv[2]) + +verbose = False +if len(sys.argv) == 4: + verbose = bool(sys.argv[3]) + +print("Comparing {} vs {}".format(old_perf_file, new_perf_file)) + +df_old = pd.read_csv (old_perf_file, sep=';', header=None, index_col=0) +df_new = pd.read_csv (new_perf_file, sep=';', header=None, index_col=0) + +for index, row in df_new.iterrows(): + if index in df_old.index: + if verbose: + print("New: ",row[1], row[2], row[3]) + print("Old: ",df_old.loc[index][1], df_old.loc[index][2], df_old.loc[index][3]) + + print(index, end=': ') + if abs(row[1] - df_old.loc[index][1]) < df_old.loc[index][1]*0.1: + print("similar performance") + elif (row[1] < df_old.loc[index][1]): + print('\x1b[3;30;42m' + 'faster' + '\x1b[0m') + elif (row[1] > df_old.loc[index][1]): + if row[1] > df_old.loc[index][1] + df_old.loc[index][1] * 0.5 : + print('\x1b[3;30;41m' + 'WAY SLOWER' + '\x1b[0m') + else: + print('\x1b[3;30;41m' + 'slower' + '\x1b[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/CenterTrack.cpp b/src/CenterTrack.cpp index dc15823..55bf82f 100644 --- a/src/CenterTrack.cpp +++ b/src/CenterTrack.cpp @@ -17,6 +17,7 @@ bool CenterTrack::init(const std::string& tensor_path, const int n_classes, cons init_pre_inf(); init_postprocessing(); init_visualization(n_classes); + return true; } bool CenterTrack::init_preprocessing(){ @@ -59,6 +60,7 @@ 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; } bool CenterTrack::init_pre_inf(){ @@ -202,6 +204,7 @@ bool CenterTrack::init_postprocessing(){ trRes.resize(nBatches); countTr.resize(nBatches, 0); trackId.resize(nBatches, 0); + return true; } bool CenterTrack::init_visualization(const int n_classes){ @@ -274,6 +277,8 @@ bool CenterTrack::init_visualization(const int n_classes){ faceId.push_back({3,0,4,7}); faceId.push_back({2,3,7,6}); // ([[0,1,5,4], [1,2,6, 5], [2,3,7,6], [3,0,4,7]]); + + return true; } void CenterTrack::_get_additional_inputs(){ @@ -308,7 +313,7 @@ void CenterTrack::preprocess(cv::Mat &frame, const int bi){ } float c[] = {new_width / 2.0f, new_height /2.0f}; - float s[] = {dim.w, 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 @@ -413,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)); @@ -424,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)); @@ -434,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; } @@ -347,21 +348,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 653624b..fd09132 100644 --- a/src/CenternetDetection3D.cpp +++ b/src/CenternetDetection3D.cpp @@ -167,6 +167,7 @@ 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; } void CenternetDetection3D::preprocess(cv::Mat &frame, const int bi){ 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 3c54e28..1d3832d 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..76c3205 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 @@ -39,7 +41,7 @@ NetworkRT::NetworkRT(Network *net, const char *name) { #if NV_TENSORRT_MAJOR >= 5 std::cout<<"DLAs: "<getNbDLACores()<<"\n"; #endif - networkRT = builderRT->createNetwork(); + networkRT = builderRT->createNetworkV2(0U); #if NV_TENSORRT_MAJOR >= 6 configRT = builderRT->createBuilderConfig(); #endif @@ -53,28 +55,27 @@ 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 @@ -104,7 +105,7 @@ NetworkRT::NetworkRT(Network *net, const char *name) { // add input layer ITensor *input = networkRT->addInput("data", DataType::kFLOAT, - DimsCHW{ dim.c, dim.h, dim.w}); + Dims3{ dim.c, dim.h, dim.w}); checkNULL(input); //add other layers @@ -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); } @@ -180,7 +200,11 @@ NetworkRT::NetworkRT(Network *net, const char *name) { output_dim.h = oDim.d[1]; output_dim.w = oDim.d[2]; output_dim.print(); - + if(builderActive){ + std::cout<<"NUMBER OF LAYERS IN NETWORK : "<getNbLayers()<getNbLayers()<getNbBindings(); i++) { Dims dim = engineRT->getBindingDimensions(i); @@ -314,6 +338,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { } ILayer *lRT = nullptr; +#if NV_TENSORRT_MAJOR < 8 if(!l->deConv) { IConvolutionLayer *lRTconv = networkRT->addConvolution(*input, l->outputs, DimsHW{l->kernelH, l->kernelW}, w, b); @@ -334,6 +359,28 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { 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) { @@ -368,19 +415,41 @@ 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 } } @@ -413,20 +482,25 @@ 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); - checkNULL(lRT); - return lRT; + 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) { - IPlugin *plugin = new ActivationLogisticRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kSIGMOID); checkNULL(lRT); return lRT; } @@ -460,8 +534,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 +544,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 +585,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; } @@ -534,32 +645,64 @@ 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); + 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) { +IPluginV2Layer* 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); + 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; } @@ -574,10 +717,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); @@ -615,6 +801,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { 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 +818,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 +848,20 @@ 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; +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; } }} 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 deffbeb..e6fb8ab 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/postprocessing.cu b/src/kernels/postprocessing.cu index 63643eb..c175e1f 100644 --- a/src/kernels/postprocessing.cu +++ b/src/kernels/postprocessing.cu @@ -46,11 +46,16 @@ void maxElem_kernel(float *src_begin, float *dst_begin, const int n_classes, con if (i > size) return; - thrust::device_ptr dPbeg ( &src_begin[i*n_classes] ) ; - thrust::device_ptr dPend = dPbeg + n_classes; - thrust::device_ptr result = thrust::max_element(thrust::device,dPbeg, dPend); + float max = 0; + int max_idx = 0; + for( int j = i*n_classes; j < i*n_classes + n_classes; ++j ){ + if( src_begin[j] > max ){ + max = src_begin[j]; + max_idx = j; + } + } - dst_begin[i] = result - dPbeg; + dst_begin[i] = max_idx - i*n_classes; } void maxElem(dnnType *src_begin, dnnType *dst_begin, const int c, const int h, const int 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/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/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 6dfbc63..f6f4e62 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/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; }