From 710cb54db36d3b3223f0a14d7e79bd1f26f46f4b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 5 Jun 2021 22:12:15 +0530 Subject: [PATCH 01/58] Centernet fix for windows --- Issues.md | 1 - src/CenternetDetection.cpp | 8 ++++---- 2 files changed, 4 insertions(+), 5 deletions(-) delete mode 100644 Issues.md diff --git a/Issues.md b/Issues.md deleted file mode 100644 index 4875b13..0000000 --- a/Issues.md +++ /dev/null @@ -1 +0,0 @@ -1)error C2131 @ Yolo3Detection.cpp(97) -> expression doesnt evaluate to a constant caused to read of variable outside its lifetime \ No newline at end of file diff --git a/src/CenternetDetection.cpp b/src/CenternetDetection.cpp index 46757f4..bd09005 100644 --- a/src/CenternetDetection.cpp +++ b/src/CenternetDetection.cpp @@ -347,21 +347,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(); -- 2.52.0 From b86a93e85d0679a1e494d98481132eb33b94ab22 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Mon, 28 Jun 2021 23:23:15 +0200 Subject: [PATCH 02/58] ActivationLeaky IpluginV2 --- CMakeLists.txt | 4 +-- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 28 ++++++++++----------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f03c98c..b163a9d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,10 +3,10 @@ cmake_minimum_required(VERSION 3.15) 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_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-unused-variable ") endif() if(WIN32) -set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) endif(WIN32) diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index 9e26b2b..850139c 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class ActivationLeakyRT : public IPlugin { +class ActivationLeakyRT : public IPluginV2 { public: ActivationLeakyRT() { @@ -13,33 +13,33 @@ public: } - int getNbOutputs() const override { + int getNbOutputs() const noexcept override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) noexcept override { return inputs[0]; } - 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); @@ -47,11 +47,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const noexcept override { return 1*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const noexcept override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, size); assert(buf == a + getSerializationSize()); -- 2.52.0 From 1412aa66c442f0e0f5eb23ec7441151282d3d9f6 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 24 Jul 2021 08:51:44 -0700 Subject: [PATCH 03/58] minor fixes for windows ,for release v0.6 --- demo/demo/seg_demo.cpp | 2 ++ include/tkDNN/CenterTrack.h | 5 +++++ include/tkDNN/CenternetDetection3D.h | 5 +++++ include/tkDNN/Layer.h | 4 ++-- include/tkDNN/SegmentationNN.h | 2 ++ include/tkDNN/demo_utils.h | 3 ++- src/CenterTrack.cpp | 23 +++++++++++++---------- 7 files changed, 31 insertions(+), 13 deletions(-) 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/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/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/Layer.h b/include/tkDNN/Layer.h index d1234a5..0c1c5ca 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; diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index b691cbc..ad21d74 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" 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/src/CenterTrack.cpp b/src/CenterTrack.cpp index dc15823..7931488 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(){ @@ -274,6 +275,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(){ @@ -413,9 +416,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 +427,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 +437,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 Date: Sun, 25 Jul 2021 23:53:30 +0530 Subject: [PATCH 04/58] fix for downloading weights(utils.cpp) when using docker --- src/utils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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"; -- 2.52.0 From d2ce966c46877495a1d9fa83edab45620173ec4e Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 4 Aug 2021 12:37:58 +0530 Subject: [PATCH 05/58] fix return type for bool functions --- include/tkDNN/SegmentationNN.h | 1 + src/CenterTrack.cpp | 4 +++- src/CenternetDetection.cpp | 1 + src/CenternetDetection3D.cpp | 1 + 4 files changed, 6 insertions(+), 1 deletion(-) diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index ad21d74..403bc28 100644 --- a/include/tkDNN/SegmentationNN.h +++ b/include/tkDNN/SegmentationNN.h @@ -183,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/src/CenterTrack.cpp b/src/CenterTrack.cpp index 7931488..55bf82f 100644 --- a/src/CenterTrack.cpp +++ b/src/CenterTrack.cpp @@ -60,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(){ @@ -203,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){ @@ -311,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 diff --git a/src/CenternetDetection.cpp b/src/CenternetDetection.cpp index bd09005..a06bc11 100644 --- a/src/CenternetDetection.cpp +++ b/src/CenternetDetection.cpp @@ -118,6 +118,7 @@ bool CenternetDetection::init(const std::string& tensor_path, const int n_classe dst2.at(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; } 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){ -- 2.52.0 From eba78e7e78093e534938b2dc32a3cfd2a16ee9e4 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 16 Aug 2021 13:59:19 +0530 Subject: [PATCH 06/58] Updates to build libkernel.so under TensorRT 8 --- CMakeLists.txt | 2 +- include/tkDNN/Int8BatchStream.h | 4 +- include/tkDNN/Int8Calibrator.h | 8 +- include/tkDNN/NetworkRT.h | 7 +- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 168 ++++++--- .../tkDNN/pluginsRT/ActivationLogisticRT.h | 107 +++++- include/tkDNN/pluginsRT/ActivationMishRT.h | 159 +++++--- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 172 ++++++--- include/tkDNN/pluginsRT/DeformableConvRT.h | 203 +++++++++- include/tkDNN/pluginsRT/FlattenConcatRT.h | 119 +++++- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 139 ++++++- include/tkDNN/pluginsRT/RegionRT.h | 125 ++++++- include/tkDNN/pluginsRT/ReorgRT.h | 115 +++++- include/tkDNN/pluginsRT/ReshapeRT.h | 122 +++++- include/tkDNN/pluginsRT/ResizeLayerRT.h | 129 ++++++- include/tkDNN/pluginsRT/RouteRT.h | 127 +++++-- include/tkDNN/pluginsRT/ShortcutRT.h | 137 +++++-- include/tkDNN/pluginsRT/UpsampleRT.h | 123 +++++-- include/tkDNN/pluginsRT/YoloRT.h | 347 ++++++++++++------ include/tkDNN/utils.h | 10 + src/Int8Calibrator.cpp | 2 +- 21 files changed, 1878 insertions(+), 447 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b366416..3e823dc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15) 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_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable ") endif() if(WIN32) set(CMAKE_CXX_STANDARD 11) 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/NetworkRT.h b/include/tkDNN/NetworkRT.h index 9892a24..53d8d91 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -40,14 +40,16 @@ using namespace nvinfer1; #include "pluginsRT/ReshapeRT.h" #include "pluginsRT/MaxPoolingFixedSizeRT.h" -class PluginFactory : IPluginFactory +/* +class PluginFactory : IPlugin { public: YoloRT *yolos[16]; int n_yolos; virtual IPlugin* createPlugin(const char* layerName, const void* serialData, size_t serialLength); -}; +};*/ + @@ -74,7 +76,6 @@ public: dnnType *output; cudaStream_t stream; - PluginFactory *pluginFactory; NetworkRT(Network *net, const char *name); virtual ~NetworkRT(); diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index 330ed37..6005013 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -1,61 +1,147 @@ -#include #include "../kernels.h" +#include -class ActivationLeakyRT : public IPlugin { +class ActivationLeakyRT : public IPluginV2 { public: - ActivationLeakyRT(float s) { - slope = s; - } + ActivationLeakyRT(float s) { slope = s; } - ~ActivationLeakyRT(){ + ActivationLeakyRT(const void *data, size_t length) + { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + slope = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); - } + } - int getNbOutputs() const override { - return 1; - } + ~ActivationLeakyRT() {} - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + int getNbOutputs() const NOEXCEPT override { return 1; } - 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, slope, + stream); + return 0; + } - activationLEAKYForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, slope, stream); - return 0; - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 1 * sizeof(int) + 1 * sizeof(float); + } + virtual void serialize(void *buffer) const NOEXCEPT override { + char *buf = reinterpret_cast(buffer), *a = buf; + tk::dnn::writeBUF(buf, size); + assert(buf == a + getSerializationSize()); + } - virtual size_t getSerializationSize() override { - return 1*sizeof(int) + 1*sizeof(float); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + const char *getPluginType() const NOEXCEPT override { + return "ActivationLeakyRT_tkDNN"; + } - int size; - float slope; + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + IPluginV2* clone() const NOEXCEPT override { + ActivationLeakyRT *p = new ActivationLeakyRT(slope); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + int size; + float slope; + +private: + std::string mPluginNamespace; }; + +class ActivationLeakyRTPluginCreator : public IPluginCreator { +public: + ActivationLeakyRTPluginCreator() { + mPluginAttributes.emplace_back( + PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { + ActivationLeakyRT *pluginObj = new ActivationLeakyRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kFLOAT32); + float slope = *(static_cast(fields[0].data)); + ActivationLeakyRT *pluginObj = new ActivationLeakyRT(slope); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationLeakyRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +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..bf4bcfd 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -1,11 +1,18 @@ #include #include "../kernels.h" -class ActivationLogisticRT : public IPlugin { +class ActivationLogisticRT : public IPluginV2 { public: ActivationLogisticRT() { + } + + ActivationLogisticRT(const void *data, size_t length) + { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); } @@ -13,33 +20,33 @@ public: } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { size = 1; for(int i=0; i(inputs[0]), reinterpret_cast(outputs[0]), batchSize*size, stream); @@ -47,14 +54,94 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 1*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer); tk::dnn::writeBUF(buf, size); } + const char *getPluginType() const NOEXCEPT override { + return "ActivationLogisticRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert; + } + + IPluginV2 *clone() const NOEXCEPT override{ + ActivationLogisticRT *p = new ActivationLogisticRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int size; + +private: + std::string mPluginNamespace; }; + +class ActivationLogisticRTPluginCreator : public IPluginCreator{ +public: + ActivationLogisticRTPluginCreator(){ + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { + ActivationLogisticRT *pluginObj = new ActivationLogisticRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { + ActivationLogisticRT *pluginObj = new ActivationLogisticRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationLogisticRT_tkDNN"; + } + +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..a34418b 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -1,61 +1,134 @@ #include #include "../kernels.h" -class ActivationMishRT : public IPlugin { +class ActivationMishRT : public IPluginV2 { public: - 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 getNbOutputs() const NOEXCEPT override { return 1; } - ~ActivationMishRT(){ + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override { + assert(format == PluginFormat::kLINEAR); + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; + } - int getNbOutputs() const override { - return 1; - } + int initialize() NOEXCEPT override { return 0; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + virtual 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(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, stream); - return 0; - } + virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override { + activationMishForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; + } - virtual size_t getSerializationSize() override { - return 1*sizeof(int); - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 1 * sizeof(int); + } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + virtual void serialize(void *buffer) const NOEXCEPT override { + char *buf = reinterpret_cast(buffer), *a = buf; + tk::dnn::writeBUF(buf, size); + assert(buf == a + getSerializationSize()); + } - int size; + const char *getPluginType() const NOEXCEPT override { + return "ActivationMishRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override { + mPluginNamespace = plguinNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override { + ActivationMishRT *p = new ActivationMishRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + int size; +private: + std::string mPluginNamespace; }; + +class ActivationMishRTPluginCreator : public IPluginCreator { +public: + ActivationMishRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + ActivationMishRT *pluginObj = new ActivationMishRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + ActivationMishRT *pluginObj = new ActivationMishRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationMishRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +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..4d2652e 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -1,63 +1,149 @@ #include #include "../kernels.h" -class ActivationReLUCeiling : public IPlugin { + +class ActivationReLUCeiling : public IPluginV2 { public: - ActivationReLUCeiling(const float ceiling) { - this->ceiling = ceiling; - } + ActivationReLUCeiling(const float ceiling) { + this->ceiling = ceiling; + } - ~ActivationReLUCeiling(){ + ~ActivationReLUCeiling() { - } + } - int getNbOutputs() const override { - return 1; - } + 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); + } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + int getNbOutputs() const NOEXCEPT override { + return 1; + } - 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, ceiling, stream); - return 0; - } + virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override { + activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); + return 0; + } - virtual size_t getSerializationSize() override { - return 1*sizeof(int) + 1*sizeof(float); - } + virtual size_t getSerializationSize() const NOEXCEPT 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, ceiling); - tk::dnn::writeBUF(buf, size); - assert(buf = a + getSerializationSize()); - - } + virtual void serialize(void *buffer) const NOEXCEPT override { + char *buf = reinterpret_cast(buffer), *a = buf; + tk::dnn::writeBUF(buf, ceiling); + tk::dnn::writeBUF(buf, size); + assert(buf = a + getSerializationSize()); - int size; - float ceiling; + } + + IPluginV2 *clone() const NOEXCEPT override { + ActivationReLUCeiling *p = new ActivationReLUCeiling(ceiling); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + } + + void destroy() NOEXCEPT override { delete this; }; + + const char *getPluginType() const NOEXCEPT override { + return "ActivationReLUCeilingRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + int size; + float ceiling; +private: + std::string mPluginNamespace; }; + +class ActivationReLUCeilingPluginCreator : public IPluginCreator { +public: + ActivationReLUCeilingPluginCreator() { + mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { + ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + float ceiling = *(static_cast(fields[0].data)); + ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(ceiling); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationReLUCeilingRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ActivationReLUCeilingPluginCreator); diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 711198f..46aa9e7 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -1,8 +1,7 @@ #include #include "../kernels.h" - -class DeformableConvRT : public IPlugin { +class DeformableConvRT : public IPluginV2 { @@ -27,6 +26,8 @@ public: this->o_c = o_c; this->o_h = o_h; this->o_w = o_w; + this->defRT = deformable; + 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; @@ -38,7 +39,6 @@ public: 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) ); @@ -61,27 +61,78 @@ public: cublasDestroy(handle); } - int getNbOutputs() const override { - return 1; + 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); + dnnType *aus = new dnnType[chunk_dim*2]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[chunk_dim]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[i_c*o_c*kh*kw*1]; + for(int i=0;i<(i_c*o_c*kh*kw*1);i++) + aus[i] = readBUF(buf); + checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[o_c]; + for(int i=0; i < o_c; i++) + aus[i] = readBUF(buf); + checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[height_ones * width_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[dim_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); + free(aus); + + assert(buf == bufCheck + length); } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; + int getNbOutputs() const NOEXCEPT override {return 1;} + + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{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 { } + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { } + virtual void terminate() NOEXCEPT override { } - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); @@ -109,13 +160,12 @@ public: return 0; } - - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT 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); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, chunk_dim); tk::dnn::writeBUF(buf, kh); @@ -166,6 +216,35 @@ public: assert(buf == a + getSerializationSize()); } + void destroy() NOEXCEPT override {delete this;} + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginType() const NOEXCEPT override{ + return "DeformableConvRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + IPluginV2* clone() const NOEXCEPT override{ + DeformableConvRT *p = 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,defRT); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + cublasStatus_t stat; cublasHandle_t handle; int i_n, i_c, i_h, i_w; @@ -193,4 +272,90 @@ public: tk::dnn::DeformConv2d *defRT; + +private: + std::string mPluginNamespace; }; + +class DeformableConvRTPluginCreator : public IPluginCreator{ +public: + DeformableConvRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + DeformableConvRT *pluginObj = new DeformableConvRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + 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[14].data)); + DeformConv2d *defRT = const_cast(static_cast(fields[15].data)); + DeformableConvRT *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,defRT); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "DeformableConvRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 51aa1ab..c8b6c0f 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,6 +1,6 @@ #include -class FlattenConcatRT : public IPlugin { +class FlattenConcatRT : public IPluginV2 { public: FlattenConcatRT() { @@ -11,19 +11,29 @@ public: } } + 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(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT 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], 1, 1}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { assert(nbOutputs == 1 && nbInputs ==1); rows = inputDims[0].d[0]; cols = inputDims[0].d[1] * inputDims[0].d[2]; @@ -32,19 +42,13 @@ public: w = 1; } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - checkERROR(cublasDestroy(handle)); - } + virtual void terminate() NOEXCEPT override { checkERROR(cublasDestroy(handle));} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override {return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT 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)); @@ -59,12 +63,11 @@ public: return 0; } - - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 5*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a = buf; tk::dnn::writeBUF(buf, c); tk::dnn::writeBUF(buf, h); @@ -74,8 +77,86 @@ public: assert(buf == a + getSerializationSize()); } + void destroy() NOEXCEPT override{delete this;} + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + const char *getPluginType() const NOEXCEPT override{ + return "FlattenConcatRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override { + FlattenConcatRT *p = new FlattenConcatRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w; int rows, cols; cublasStatus_t stat; - cublasHandle_t handle; + cublasHandle_t handle; +private: + std::string mPluginNamespace; }; + +class FlattenConcatRTPluginCreator : public IPluginCreator{ +public: + FlattenConcatRTPluginCreator(){ + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + FlattenConcatRT *pluginObj = new FlattenConcatRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + FlattenConcatRT *pluginObj = new FlattenConcatRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "FlattenConcatRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +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..53fdd4e 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -1,7 +1,8 @@ #include #include "../kernels.h" -class MaxPoolFixedSizeRT : public IPlugin { + +class MaxPoolFixedSizeRT : public IPluginV2 { public: MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) { @@ -15,32 +16,40 @@ public: this->padding = padding; } + 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(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{this->c, this->h, this->w}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{this->c, this->h, this->w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override {} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { //std::cout<n<<" "<c<<" "<h<<" "<w<<" "<stride_H<<" "<stride_W<<" "<winSize<<" "<padding<(inputs[0]); @@ -50,11 +59,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 8*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, this->c); @@ -68,8 +77,106 @@ public: assert(buf == a + getSerializationSize()); } + void destroy() NOEXCEPT override{delete this;} + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + const char *getPluginType() const NOEXCEPT override{ + return "MaxPoolingFixedSizeRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + IPluginV2 *clone() const NOEXCEPT override{ + MaxPoolFixedSizeRT *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + int n, c, h, w; int stride_H, stride_W; int winSize; int padding; + +private: + std::string mPluginNamespace; }; + +class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator{ +public: + MaxPoolFixedSizeRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + //todo assert + 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)); + MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "MaxPoolingFixedSizeRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +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..8e1c2d2 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -1,11 +1,10 @@ #include #include "../kernels.h" -class RegionRT : public IPlugin { +class RegionRT : public IPluginV2 { public: RegionRT(int classes, int coords, int num) { - this->classes = classes; this->coords = coords; this->num = num; @@ -15,33 +14,39 @@ public: } - int getNbOutputs() const override { + 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 getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override { return 0; } - return 0; - } - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override { } - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0; } - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); @@ -68,11 +73,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 6*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, classes); tk::dnn::writeBUF(buf, coords); @@ -83,6 +88,34 @@ public: assert(buf == a + getSerializationSize()); } + const char *getPluginType() const NOEXCEPT override{ + return "RegionRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + void destroy() NOEXCEPT override {delete this;} + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + IPluginV2* clone() const NOEXCEPT override{ + RegionRT *p = new RegionRT(classes,coords,num); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w; int classes, coords, num; @@ -92,4 +125,64 @@ public: 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(){ + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ + RegionRT *pluginObj = new RegionRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int classes = *(static_cast(fields[0].data)); + int coords = *(static_cast(fields[1].data)); + int num = *(static_cast(fields[2].data)); + RegionRT *pluginObj = new RegionRT(classes,coords,num); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + + } + + const char *getPluginName() const NOEXCEPT override{ + return "RegionRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(RegionRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index c1b529a..01e5468 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class ReorgRT : public IPlugin { +class ReorgRT : public IPluginV2 { public: ReorgRT(int stride) { @@ -12,33 +12,34 @@ public: } - int getNbOutputs() const override { - return 1; + 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); } - 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}; + int getNbOutputs() const NOEXCEPT override {return 1;} + + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override { return 0;} - return 0; - } + virtual void terminate() NOEXCEPT override {} - virtual void terminate() override { - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - 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 { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { reorgForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), @@ -47,11 +48,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, stride); tk::dnn::writeBUF(buf, c); @@ -59,6 +60,84 @@ public: tk::dnn::writeBUF(buf, w); assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{return true;} + + const char *getPluginType() const NOEXCEPT override{ + return "ReorgRT_tkDNN"; + } + + const char* getPluginVersion() const NOEXCEPT override{ + return "1"; + } + void destroy() NOEXCEPT override{ delete this;} + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2* clone() const NOEXCEPT override{ + ReorgRT *p = new ReorgRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } int c, h, w, stride; +private: + std::string mPluginNamespace; }; + +class ReorgRTPluginCreator : public IPluginCreator{ +public: + ReorgRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2* deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + ReorgRT *pluginObj = new ReorgRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection* fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kINT32); + int stride = *(static_cast(fields[0].data)); + ReorgRT *pluginObj = new ReorgRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ReorgRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +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..fd74c61 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -1,42 +1,47 @@ #include -class ReshapeRT : public IPlugin { +class ReshapeRT : public IPluginV2 { public: - ReshapeRT(dataDim_t new_dim) { + ReshapeRT(dataDim_t newDim) { + new_dim = newDim; n = new_dim.n; c = new_dim.c; h = new_dim.h; w = new_dim.w; } + ReshapeRT(const void *data,size_t length){ + const char *buf = reinterpret_cast(data),*bufCheck = buf; + new_dim.n = readBUF(buf); + new_dim.c = readBUF(buf); + new_dim.h = readBUF(buf); + new_dim.w = readBUF(buf); + assert(buf == bufCheck + length); + } + ~ReshapeRT(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{ c,h,w}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{ c,h,w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override {} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); @@ -44,12 +49,11 @@ public: return 0; } - - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a = buf; tk::dnn::writeBUF(buf, n); tk::dnn::writeBUF(buf, c); @@ -58,5 +62,87 @@ public: assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + + const char *getPluginType() const NOEXCEPT override{ + return "1"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "ReshapeRT_tkDNN"; + } + + void destroy() NOEXCEPT override{delete this;} + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override{ + ReshapeRT *p = new ReshapeRT(new_dim); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int n, c, h, w; + dataDim_t new_dim; +private: + std::string mPluginNamespace; }; + +class ReshapeRTPluginCreator : public IPluginCreator{ +public: + ReshapeRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ + ReshapeRT *pluginObj = new ReshapeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + dataDim_t newDim = *(static_cast(fields[0].data)); + ReshapeRT *pluginObj = new ReshapeRT(newDim); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ReshapeRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ReshapeRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index cde52bf..9a982fd 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class ResizeLayerRT : public IPlugin { +class ResizeLayerRT : public IPluginV2 { public: ResizeLayerRT(int c, int h, int w) { @@ -10,35 +10,41 @@ public: o_w = w; } + 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(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{o_c, o_h, o_w}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{o_c, o_h, o_w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { i_c = inputDims[0].d[0]; i_h = inputDims[0].d[1]; i_w = inputDims[0].d[2]; } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override {} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT 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]), @@ -47,11 +53,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 6*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, o_c); @@ -64,5 +70,96 @@ public: assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + + const char *getPluginType() const NOEXCEPT override{ + return "ResizeLayerRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + void destroy() NOEXCEPT override{delete this;} + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + IPluginV2 *clone() const NOEXCEPT override{ + ResizeLayerRT *p = new ResizeLayerRT(o_c,o_h,o_w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int i_c, i_h, i_w, o_c, o_h, o_w; + +private: + std::string mPluginNamespace; }; + +class ResizeLayerRTPluginCreator : public IPluginCreator{ +public: + ResizeLayerRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + ResizeLayerRT *pluginObj = new ResizeLayerRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int oc = *(static_cast(fields[0].data)); + int oh = *(static_cast(fields[1].data)); + int ow = *(static_cast(fields[2].data)); + ResizeLayerRT *pluginObj = new ResizeLayerRT(oc,oh,ow); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ResizeLayerRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + +}; + +REGISTER_TENSORRT_PLUGIN(ResizeLayerRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 5a8c170..635566c 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class RouteRT : public IPlugin { +class RouteRT : public IPluginV2 { /** THIS IS NOT USED ANYMORE @@ -17,17 +17,31 @@ public: } - int getNbOutputs() const override { + 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 getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { int out_c = 0; for(int i=0; i(outputs[0]); - for(int b=0; b(buffer),*a=buf; tk::dnn::writeBUF(buf, groups); tk::dnn::writeBUF(buf, group_id); @@ -88,9 +92,90 @@ public: assert(buf == a + getSerializationSize()); } + const char *getPluginType() const NOEXCEPT override{ + return "RouteRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + void destroy() NOEXCEPT override {delete this; } + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override { return true;} + + IPluginV2* clone() const NOEXCEPT override{ + RouteRT *p = new RouteRT(groups,group_id); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } static const int MAX_INPUTS = 4; int in; int c_in[MAX_INPUTS]; int c, h, w; int groups, group_id; +private: + std::string mPluginNamespace; }; + +class RouteRTPluginCreator : public IPluginCreator{ +public: + RouteRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + RouteRT *pluginObj = new RouteRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + 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 *getPluginName() const NOEXCEPT override{ + return "RouteRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(RouteRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 04091ac..f5b8219 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -1,47 +1,52 @@ #include #include "../kernels.h" -class ShortcutRT : public IPlugin { + +class ShortcutRT : public IPluginV2 { public: ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - this->bc = bdim.c; - this->bh = bdim.h; - this->bw = bdim.w; + bDim = bdim; + this->bc = bDim.c; + this->bh = bDim.h; + this->bw = bDim.w; this->mul = mul; } - ~ShortcutRT(){ + ~ShortcutRT(){} + ShortcutRT(const void* data,size_t length){ + const char* buf =reinterpret_cast(data),*bufCheck = buf; + bDim.c = readBUF(buf); + bDim.h = readBUF(buf); + bDim.w = readBUF(buf); + bDim.l = 1; + mul = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); } - int getNbOutputs() const override { - return 1; + int getNbOutputs() const NOEXCEPT override {return 1;} + + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; } - 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 { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override {return 0;} - return 0; - } + virtual void terminate() NOEXCEPT override {} - virtual void terminate() override { - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - 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 { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); @@ -54,11 +59,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 6*sizeof(int) + sizeof(bool); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, bc); tk::dnn::writeBUF(buf, bh); @@ -71,7 +76,91 @@ public: } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + const char* getPluginType() const NOEXCEPT override{ + return "1"; + } + + const char* getPluginVersion() const NOEXCEPT override{ + return "ShortcutRT_tkDNN"; + } + + void destroy() NOEXCEPT override{delete this;} + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override{ + ShortcutRT *p = new ShortcutRT(bDim,mul); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w; int bc, bh, bw; bool mul; + tk::dnn::dataDim_t bDim; +private: + std::string mPluginNamespace; }; + + +class ShortcutRTPluginCreator : public IPluginCreator { +public: + ShortcutRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + ShortcutRT *pluginObj = new ShortcutRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + //todo assert + tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); + bool mul = *(static_cast(fields[1].data)); + ShortcutRT *pluginObj = new ShortcutRT(bdim,mul); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ShortcutRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ShortcutRTPluginCreator); \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index a11d7b4..0a71c45 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -1,44 +1,47 @@ #include #include "../kernels.h" -class UpsampleRT : public IPlugin { + +class UpsampleRT : public IPluginV2 { public: UpsampleRT(int stride) { this->stride = stride; } - ~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); } - int getNbOutputs() const override { + + ~UpsampleRT(){} + + int getNbOutputs() const NOEXCEPT override { return 1; } - 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); + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override {return 0;} - return 0; - } + virtual void terminate() NOEXCEPT override {} - virtual void terminate() override { - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - 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 { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); @@ -49,11 +52,9 @@ public: } - virtual size_t getSerializationSize() override { - return 4*sizeof(int); - } + virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int);} - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, stride); tk::dnn::writeBUF(buf, c); @@ -62,5 +63,85 @@ public: assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + //todo assert + return true; + } + + const char *getPluginType() const NOEXCEPT override{ + return "1"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "UpsampleRT_tkDNN"; + } + + void destroy() NOEXCEPT override{delete this;} + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2* clone() const NOEXCEPT override{ + UpsampleRT *p = new UpsampleRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w, stride; +private: + std::string mPluginNamespace; }; + +class UpsampleRTPluginCreator : public IPluginCreator{ +public: + UpsampleRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + UpsampleRT *pluginObj = new UpsampleRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + int stride = *(static_cast(fields[0].data)); + UpsampleRT *pluginObj = new UpsampleRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "UpsampleRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 5ffe39c..cc866c6 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,143 +1,268 @@ #include #include "../kernels.h" - #define YOLORT_CLASSNAME_W 256 -class YoloRT : public IPlugin { - - +class YoloRT : public IPluginV2 { 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) { - - 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(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) { + this->yolo = Yolo; + 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; 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; + 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; } - } + } - ~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); + for(int i=0;i(buf); + for(int i=0;i(buf); + classesNames.resize(classes); + for(int i=0;i(buf); + classesNames[1] = std::string(tmp); + } + assert(buf == bufCheck + length); + } - } + ~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)); + } - 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 + int getNbOutputs() const NOEXCEPT override { + return 1; + } - if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1); + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { + return inputs[0]; + } - index = entry_index(b, n*w*h, 4); - activationLOGISTICForward(srcData + index, dstData + index, (1+classes)*w*h, stream); + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; + } + + int initialize() NOEXCEPT override { + + return 0; + } + + virtual void terminate() NOEXCEPT override { + } + + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { + return 0; + } + + virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT 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 < 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; - } + //std::cout<<"YOLO END\n"; + return 0; + } - 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); - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + + YOLORT_CLASSNAME_W * classes * sizeof(char); + } - 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; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { + return true; //todo implement proper supportsFormat + } - // save classes names - for(int i=0; i(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; + } - int c, h, w; + // save classes names + for (int i = 0; i < classes; i++) { + char tmp[YOLORT_CLASSNAME_W]; + strcpy(tmp, classesNames[i].c_str()); + for (int j = 0; j < YOLORT_CLASSNAME_W; j++) { + tk::dnn::writeBUF(buf, tmp[j]); + } + } + assert(buf == a + getSerializationSize()); + } + + const char *getPluginType() const NOEXCEPT override { + return "YoloRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override { + YoloRT *p = new YoloRT(classes, num,yolo, n_masks, scaleXY, nms_thresh, nms_kind, new_coords); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + Yolo *yolo; + int c, h, w; int classes, num, n_masks; - float scaleXY; - float nms_thresh; - int nms_kind; - int new_coords; - std::vector classesNames; + float scaleXY; + float nms_thresh; + int nms_kind; + int new_coords; + std::vector classesNames; dnnType *mask; dnnType *bias; - 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; - } + 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; + } + +private: + std::string mPluginNamespace; }; + +class YoloRTPluginCreator : public IPluginCreator{ +public: + YoloRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + YoloRT *pluginObj = new YoloRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + //todo assert + int classes = *(static_cast(fields[0].data)); + int num = *(static_cast(fields[1].data)); + Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); + int numMasks = *(static_cast(fields[3].data)); + float scaleXY = *(static_cast(fields[4].data)); + float nmsThresh = *(static_cast(fields[5].data)); + int nmsKind = *(static_cast(fields[6].data)); + int newCoords = *(static_cast(fields[7].data)); + YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "YoloRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(YoloRTPluginCreator); diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 65375ba..8041f3b 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -11,6 +11,7 @@ #include "cuda_runtime_api.h" #include #include +#include #ifdef __linux__ @@ -22,6 +23,15 @@ #include + + +#if NV_TENSORRT_MAJOR > 7 +#define NOEXCEPT noexcept +#else +#define NOEXCEPT +#endif + + #define dnnType float diff --git a/src/Int8Calibrator.cpp b/src/Int8Calibrator.cpp index 773a9d8..9fab18f 100644 --- a/src/Int8Calibrator.cpp +++ b/src/Int8Calibrator.cpp @@ -8,7 +8,7 @@ Int8EntropyCalibrator::Int8EntropyCalibrator(BatchStream& stream, int firstBatch mCalibTableFilePath(calibTableFilePath), mInputBlobName(inputBlobName.c_str()), mReadCache(readCache) { - nvinfer1::DimsNCHW dims = mStream.getDims(); + nvinfer1::Dims4 dims = mStream.getDims(); mInputCount = mStream.getBatchSize() * dims.c() * dims.h() * dims.w(); checkCuda(cudaMalloc(&mDeviceInput, mInputCount * sizeof(float))); mStream.reset(firstBatch); -- 2.52.0 From 3d8b1ac49475d0e3a20432b2317a34a5d183e39b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 21 Aug 2021 22:29:36 +0530 Subject: [PATCH 07/58] Yolo3Detection.cpp doesn't build yet,issues with dependecies of preprocessing and postprocessing on IPluginFactory --- include/tkDNN/pluginsRT/YoloRT.h | 4 ++ include/tkDNN/utils.h | 2 + src/Int8BatchStream.cpp | 20 ++++---- src/Int8Calibrator.cpp | 8 ++-- src/NetworkRT.cpp | 80 ++++++++++++++++---------------- src/Yolo3Detection.cpp | 1 + tests/mnist/test_mnistRT.cpp | 10 ++-- 7 files changed, 65 insertions(+), 60 deletions(-) diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index cc866c6..3511634 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -2,6 +2,7 @@ #include "../kernels.h" #define YOLORT_CLASSNAME_W 256 + class YoloRT : public IPluginV2 { public: @@ -49,6 +50,7 @@ public: classesNames[1] = std::string(tmp); } assert(buf == bufCheck + length); + } ~YoloRT() { @@ -56,6 +58,7 @@ public: } + int getNbOutputs() const NOEXCEPT override { return 1; } @@ -186,6 +189,7 @@ public: float nms_thresh; int nms_kind; int new_coords; + int NUM=0; std::vector classesNames; dnnType *mask; diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 8041f3b..017cf1d 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -147,4 +147,6 @@ static inline bool isCudaPointer(void *data) { cudaPointerAttributes attr; return cudaPointerGetAttributes(&attr, data) == 0; } + + #endif //UTILS_H 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 9fab18f..691f847 100644 --- a/src/Int8Calibrator.cpp +++ b/src/Int8Calibrator.cpp @@ -9,12 +9,12 @@ Int8EntropyCalibrator::Int8EntropyCalibrator(BatchStream& stream, int firstBatch mInputBlobName(inputBlobName.c_str()), mReadCache(readCache) { nvinfer1::Dims4 dims = mStream.getDims(); - mInputCount = mStream.getBatchSize() * dims.c() * dims.h() * dims.w(); + 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/NetworkRT.cpp b/src/NetworkRT.cpp index 6ac7235..43ba4ba 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.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 { #ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; #endif @@ -39,7 +39,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 @@ -59,22 +59,21 @@ NetworkRT::NetworkRT(Network *net, const char *name) { dtRT = DataType::kFLOAT; builderRT->setMaxBatchSize(net->maxBatchSize); - builderRT->setMaxWorkspaceSize(1 << 30); + configRT->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 +103,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 @@ -368,8 +367,8 @@ 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); + IPluginV2 *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); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -413,20 +412,20 @@ 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); + IPluginV2 *plugin = new ActivationReLUCeiling(l->ceiling); + 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); + IPluginV2 *plugin = new ActivationMishRT(); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } else if(l->act_mode == ACTIVATION_LOGISTIC) { - IPlugin *plugin = new ActivationLogisticRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new ActivationLogisticRT(); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -460,8 +459,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; } @@ -472,8 +471,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { - IPlugin *plugin = new FlattenConcatRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new FlattenConcatRT(); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -481,8 +480,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { ILayer* 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); + IPluginV2 *plugin = new ReshapeRT(l->output_dim); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -494,7 +493,7 @@ 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; } @@ -502,8 +501,8 @@ ILayer* 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); + IPluginV2 *plugin = new ReorgRT(l->stride); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -512,8 +511,8 @@ ILayer* 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); + IPluginV2 *plugin = new RegionRT(l->classes, l->coords, l->num); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -534,11 +533,11 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { else { // plugin version - IPlugin *plugin = new ShortcutRT(l->backLayer->output_dim, l->mul); + IPluginV2 *plugin = new ShortcutRT(l->backLayer->output_dim, l->mul); ITensor **inputs = new ITensor*[2]; inputs[0] = input; inputs[1] = back_tens; - IPluginLayer *lRT = networkRT->addPlugin(inputs, 2, *plugin); + IPluginV2Layer *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); return lRT; } @@ -548,8 +547,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { //std::cout<<"convert Yolo\n"; //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); + IPluginV2 *plugin = new YoloRT(l->classes, l->num, l, l->n_masks, l->scaleXY, l->nms_thresh, l->nsm_kind, l->new_coords); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -558,8 +557,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; //std::cout<<"New plugin UPSAMPLE\n"; - IPlugin *plugin = new UpsampleRT(l->stride); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new UpsampleRT(l->stride); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -574,10 +573,10 @@ 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, + IPluginV2 *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); + IPluginV2Layer *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); lRT->setName( ("Deformable" + std::to_string(l->id)).c_str() ); delete[](inputs); @@ -646,16 +645,15 @@ 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); //if (gieModelStream) delete [] gieModelStream; return true; } - +/* IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialData, size_t serialLength) { const char * buf = reinterpret_cast(serialData),*bufCheck = buf; @@ -897,5 +895,5 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa FatalError("Cant deserialize Plugin"); return NULL; } - +*/ }} diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 0c638e6..9de35e2 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -14,6 +14,7 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, c tk::dnn::dataDim_t idim = netRT->input_dim; idim.n = nBatches; + if(netRT->pluginFactory->n_yolos < 2 ) { FatalError("this is not yolo3"); } diff --git a/tests/mnist/test_mnistRT.cpp b/tests/mnist/test_mnistRT.cpp index 1b4e9c3..fe25696 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,7 +126,7 @@ int main() { // Build the engine builder->setMaxBatchSize(1); - builder->setMaxWorkspaceSize(1 << 20); + config->setMaxWorkspaceSize(1 << 20); auto engine = builder->buildCudaEngine(*network); // we don't need the network any more -- 2.52.0 From 2ffe07057e550d2fd48588e72099ac8ecaa06ae3 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 29 Aug 2021 03:18:58 +0530 Subject: [PATCH 08/58] Mnist works at the moment with trt8,others like yolo4tiny and mobilenet generate the engine files but crash after throwing nvifer1::CudaRuntimeError and when demo is being run ,it doesnt deserialize properly and crashes --- CMakeLists.txt | 3 +- demo/demo/demo.cpp | 49 +++++++---- include/tkDNN/DarknetParser.h | 3 + include/tkDNN/DetectionNN.h | 2 +- include/tkDNN/NetworkRT.h | 2 +- include/tkDNN/Yolo3Detection.h | 7 +- include/tkDNN/pluginsRT/ReorgRT.h | 2 +- include/tkDNN/pluginsRT/YoloRT.h | 1 + src/DarknetParser.cpp | 141 +++++++++++++++++++++++++++++- src/NetworkRT.cpp | 34 +++++++ src/Yolo3Detection.cpp | 51 +++++++---- tests/mnist/test_mnistRT.cpp | 2 +- 12 files changed, 255 insertions(+), 42 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3e823dc..d88407e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,12 +33,13 @@ 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" ) 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}) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 317a574..6e1c2b4 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -23,6 +23,18 @@ int main(int argc, char *argv[]) { std::string net = "yolo4tiny_fp32.rt"; + #ifdef __linux__ + std::string cfgPath = "../tests/darknet/cfg/yolo4tiny.cfg"; + #elif _WIN32 + std::string cfgPath = "..\\tests\\darknet\\cfg\\yolo4tiny.cfg"; + #endif + + #ifdef __linux__ + std::string namePath = "../tests/darknet/names/coco.names"; + #elif _WIN32 + std::string namePath = "..\\tests\\darknet\\names\\coco.names"; + #endif + if(argc > 1) net = argv[1]; #ifdef __linux__ @@ -31,23 +43,28 @@ int main(int argc, char *argv[]) { std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; #endif + if(argc > 2) - input = argv[2]; - char ntype = 'y'; + cfgPath = argv[2]; if(argc > 3) - ntype = argv[3][0]; - int n_classes = 80; + namePath = argv[3]; if(argc > 4) - n_classes = atoi(argv[4]); - int n_batch = 1; + input = argv[4]; + char ntype = 'y'; if(argc > 5) - n_batch = atoi(argv[5]); - bool show = true; + ntype = argv[5][0]; + int n_classes = 80; if(argc > 6) - show = atoi(argv[6]); - float conf_thresh=0.3; + n_classes = atoi(argv[6]); + int n_batch = 1; if(argc > 7) - conf_thresh = atof(argv[7]); + n_batch = atoi(argv[7]); + bool show = true; + if(argc > 8) + show = atoi(argv[8]); + float conf_thresh=0.3; + if(argc > 9) + conf_thresh = atof(argv[9]); if(n_batch < 1 || n_batch > 64) FatalError("Batch dim not supported"); @@ -56,8 +73,8 @@ int main(int argc, char *argv[]) { SAVE_RESULT = true; tk::dnn::Yolo3Detection yolo; - tk::dnn::CenternetDetection cnet; - tk::dnn::MobilenetDetection mbnet; + //tk::dnn::CenternetDetection cnet; + //tk::dnn::MobilenetDetection mbnet; tk::dnn::DetectionNN *detNN; @@ -67,17 +84,17 @@ int main(int argc, char *argv[]) { detNN = &yolo; break; case 'c': - detNN = &cnet; + //detNN = &cnet; break; case 'm': - detNN = &mbnet; + //detNN = &mbnet; n_classes++; break; default: FatalError("Network type not allowed (3rd parameter)\n"); } - detNN->init(net, n_classes, n_batch, conf_thresh); + detNN->init(net,cfgPath,namePath,n_classes,n_batch,conf_thresh); gRun = true; 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/NetworkRT.h b/include/tkDNN/NetworkRT.h index 53d8d91..4a0d5ff 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -7,6 +7,7 @@ #include "Layer.h" #include "NvInfer.h" #include +#include namespace tk { namespace dnn { @@ -52,7 +53,6 @@ public: - class NetworkRT { public: 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/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index 01e5468..fa67d9c 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -41,7 +41,7 @@ public: virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - reorgForward((dnnType*)reinterpret_cast(inputs[0]), + reorgForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), batchSize, c, h, w, stride, stream); return 0; diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 3511634..d40cd5c 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -31,6 +31,7 @@ public: classes = readBUF(buf); num = readBUF(buf); n_masks = readBUF(buf); + std::cout<(buf); nms_thresh = readBUF(buf); nms_kind = readBUF(buf); diff --git a/src/DarknetParser.cpp b/src/DarknetParser.cpp index 69b6b29..a370b91 100644 --- a/src/DarknetParser.cpp +++ b/src/DarknetParser.cpp @@ -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,134 @@ 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 <=20){ + 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"< tk::dnn::ActivationLeakyRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ActivationReLUCeilingPluginCreator::mPluginAttributes; +std::vector tk::dnn::ActivationMishRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ActivationLogisticRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::DeformableConvRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::RegionRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ReorgRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::UpsampleRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ShortcutRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ReshapeRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ResizeLayerRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::YoloRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::RouteRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::FlattenConcatRTPluginCreator::mPluginAttributes; + // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 9de35e2..26da756 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -3,7 +3,7 @@ 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"; @@ -14,28 +14,42 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, c tk::dnn::dataDim_t idim = netRT->input_dim; idim.n = nBatches; + std::vector yolosLine = noYolosLine(cfg_path); + noYolos = yolosLine; + int channels,height,width; + loadYoloInitInfo(channels,width,height,cfg_path); - if(netRT->pluginFactory->n_yolos < 2 ) { + + + 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 classes,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); + yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, channels, height, width); + 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); @@ -94,10 +108,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); @@ -105,7 +124,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/tests/mnist/test_mnistRT.cpp b/tests/mnist/test_mnistRT.cpp index fe25696..2f6b7c4 100644 --- a/tests/mnist/test_mnistRT.cpp +++ b/tests/mnist/test_mnistRT.cpp @@ -128,7 +128,7 @@ int main() { builder->setMaxBatchSize(1); 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(); -- 2.52.0 From de83ae5d254fbfeeadbb2fdf7c0dc0eded5a749d Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 30 Aug 2021 19:04:26 +0530 Subject: [PATCH 09/58] update tensorrt8 branch --- CMakeLists.txt | 15 ++-- include/tkDNN/NetworkRT.h | 1 + include/tkDNN/pluginsRT/ActivationLeakyRT.h | 5 +- .../tkDNN/pluginsRT/ActivationLogisticRT.h | 4 +- include/tkDNN/pluginsRT/ActivationMishRT.h | 5 +- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 7 +- include/tkDNN/pluginsRT/DeformableConvRT.h | 5 +- include/tkDNN/pluginsRT/FlattenConcatRT.h | 4 +- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 4 +- include/tkDNN/pluginsRT/RegionRT.h | 4 +- include/tkDNN/pluginsRT/ReorgRT.h | 4 +- include/tkDNN/pluginsRT/ReshapeRT.h | 4 +- include/tkDNN/pluginsRT/ResizeLayerRT.h | 4 +- include/tkDNN/pluginsRT/RouteRT.h | 4 +- include/tkDNN/pluginsRT/ShortcutRT.h | 6 +- include/tkDNN/pluginsRT/UpsampleRT.h | 11 ++- include/tkDNN/pluginsRT/YoloRT.h | 23 ++++-- src/NetworkRT.cpp | 74 +++++++------------ src/Yolo3Detection.cpp | 2 +- tests/darknet/yolo4tiny.cpp | 7 ++ 20 files changed, 96 insertions(+), 97 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d88407e..9200b8c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15) project (tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable ") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable") endif() if(WIN32) set(CMAKE_CXX_STANDARD 11) @@ -31,7 +31,7 @@ endif() find_package(CUDA 9.0 REQUIRED) SET(CUDA_SEPARABLE_COMPILATION ON) #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) +set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) find_package(CUDNN REQUIRED) @@ -41,8 +41,7 @@ include_directories(${CUDNN_INCLUDE_DIR}) # compile file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" ) 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}) + #------------------------------------------------------------------------------- @@ -65,12 +64,12 @@ find_package(yaml-cpp REQUIRED) # Build Libraries #------------------------------------------------------------------------------- file(GLOB tkdnn_SRC "src/*.cpp") -set(tkdnn_LIBS kernels ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) +set(tkdnn_LIBS ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) 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}) +cuda_add_library(tkDNN SHARED ${tkdnn_SRC} ${tkdnn_CUSRC}) +target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRAY}) #static #add_library(tkDNN_static STATIC ${tkdnn_SRC}) @@ -169,7 +168,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/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 4a0d5ff..95ecb5e 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -119,6 +119,7 @@ public: bool serialize(const char *filename); bool deserialize(const char *filename); + void destroy(); diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index 6005013..e73ca2b 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -8,6 +8,7 @@ public: ActivationLeakyRT(const void *data, size_t length) { + std::cout<<"DESERIALIZE LEAKYRT"<(data),*bufCheck = buf; slope = readBUF(buf); size = readBUF(buf); @@ -139,8 +140,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index bf4bcfd..e40e7b4 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -139,8 +139,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index a34418b..65153d0 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -9,6 +9,7 @@ public: ~ActivationMishRT() {} ActivationMishRT(const void *data, size_t length) { + std::cout<<"DESERIALIZE MISH"<(data), *bufCheck = buf; size = readBUF(buf); assert(buf == bufCheck + length); @@ -126,8 +127,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index 4d2652e..8d295df 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -14,6 +14,7 @@ public: } ActivationReLUCeiling(const void *data, size_t length) { + std::cout<<"RELU CEILING DESERIALIZE"<(data), *bufCheck = buf; ceiling = readBUF(buf); size = readBUF(buf); @@ -140,9 +141,9 @@ public: return &mFC; } -private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; +public: + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 46aa9e7..7076379 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -352,10 +352,9 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; -REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index c8b6c0f..3c6f3ee 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -154,8 +154,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 53fdd4e..ef5a8f7 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -173,8 +173,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index 8e1c2d2..e187d6c 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -179,8 +179,8 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index fa67d9c..7605fde 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -134,8 +134,8 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index fd74c61..17037da 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -140,8 +140,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index 9a982fd..374b7d8 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -155,8 +155,8 @@ public: private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 635566c..2ceede3 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -173,8 +173,8 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index f5b8219..9f3d343 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -157,9 +157,9 @@ public: const PluginFieldCollection *getFieldNames() NOEXCEPT override{ return &mFC; } -private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; +public: + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 0a71c45..9d7a62c 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -73,7 +73,8 @@ public: } const char *getPluginVersion() const NOEXCEPT override{ - return "UpsampleRT_tkDNN"; + static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; + return UPSAMPLE_RT_PLUGIN; } void destroy() NOEXCEPT override{delete this;} @@ -128,7 +129,8 @@ public: } const char *getPluginName() const NOEXCEPT override{ - return "UpsampleRT_tkDNN"; + static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; + return UPSAMPLE_RT_PLUGIN; } const char *getPluginVersion() const NOEXCEPT override{ @@ -139,9 +141,10 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index d40cd5c..7ae7b35 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,4 +1,5 @@ #include +#include #include "../kernels.h" #define YOLORT_CLASSNAME_W 256 @@ -27,11 +28,12 @@ public: } YoloRT(const void *data,size_t length){ + std::vector maskTemp,biasTemp; + std::cout<<"LENGTH : "<(data),*bufCheck = buf; classes = readBUF(buf); num = readBUF(buf); n_masks = readBUF(buf); - std::cout<(buf); nms_thresh = readBUF(buf); nms_kind = readBUF(buf); @@ -39,10 +41,16 @@ public: c = readBUF(buf); h = readBUF(buf); w = readBUF(buf); - for(int i=0;i(buf); - for(int i=0;i(buf); + for(int i=0;i(buf)); + std::cout<(buf)); + std::cout<(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; + std::cout< mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 102562f..7f00cd6 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -8,45 +8,13 @@ #include "utils.h" #include "NvInfer.h" + #include "NetworkRT.h" #include "Int8Calibrator.h" using namespace nvinfer1; -PluginFieldCollection tk::dnn::ActivationLeakyRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ActivationReLUCeilingPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ActivationMishRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ActivationLogisticRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::DeformableConvRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::RegionRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ReorgRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::UpsampleRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ShortcutRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ReshapeRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::MaxPoolFixedSizeRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ResizeLayerRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::YoloRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::RouteRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::FlattenConcatRTPluginCreator::mFC{}; - - -std::vector tk::dnn::ActivationLeakyRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ActivationReLUCeilingPluginCreator::mPluginAttributes; -std::vector tk::dnn::ActivationMishRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ActivationLogisticRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::DeformableConvRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::RegionRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ReorgRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::UpsampleRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ShortcutRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ReshapeRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ResizeLayerRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::YoloRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::RouteRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::FlattenConcatRTPluginCreator::mPluginAttributes; - // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { @@ -590,7 +558,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; - //std::cout<<"New plugin UPSAMPLE\n"; + std::cout<<"New plugin UPSAMPLE\n"; IPluginV2 *plugin = new UpsampleRT(l->stride); IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); @@ -681,11 +649,21 @@ bool NetworkRT::deserialize(const char *filename) { runtimeRT = createInferRuntime(loggerRT); engineRT = runtimeRT->deserializeCudaEngine(gieModelStream, size); + std::cout<destroy(); + configRT->destroy(); + engineRT->destroy(); + builderRT->destroy(); +} + + + /* IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialData, size_t serialLength) { @@ -735,7 +713,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Reorg") == 0) { int strideTemp = readBUF(buf); @@ -745,7 +723,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Shortcut") == 0) { tk::dnn::dataDim_t bdim; @@ -760,7 +738,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); return r; assert(buf == bufCheck + serialLength); - } + } if(name.find("Pooling") == 0) { int cTemp = readBUF(buf); @@ -788,10 +766,10 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->i_w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Flatten") == 0) { - FlattenConcatRT *r = new FlattenConcatRT(); + FlattenConcatRT *r = new FlattenConcatRT(); r->c = readBUF(buf); r->h = readBUF(buf); r->w = readBUF(buf); @@ -799,7 +777,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->cols = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Reshape") == 0) { @@ -808,11 +786,11 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa new_dim.c = readBUF(buf); new_dim.h = readBUF(buf); new_dim.w = readBUF(buf); - ReshapeRT *r = new ReshapeRT(new_dim); + ReshapeRT *r = new ReshapeRT(new_dim); assert(buf == bufCheck + serialLength); - + return r; - } + } if(name.find("Yolo") == 0) { @@ -824,7 +802,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa 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); + YoloRT *r = new YoloRT(classes_temp,num_temp,nullptr,n_masks_temp,scale_xy_temp,nms_thresh_temp,nms_kind_temp,new_coords_temp); @@ -848,7 +826,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa yolos[n_yolos++] = r; return r; - } + } if(name.find("Upsample") == 0) { int strideTemp = readBUF(buf); UpsampleRT* r = new UpsampleRT(strideTemp); @@ -857,7 +835,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Route") == 0) { int groupsTemp = readBUF(buf); @@ -871,7 +849,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Deformable") == 0) { int chuck_dimTemp = readBUF(buf); @@ -924,7 +902,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa free(aus); assert(buf == bufCheck + serialLength); return r; - } + } FatalError("Cant deserialize Plugin"); return NULL; diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 26da756..8d3d244 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -7,7 +7,7 @@ namespace tk { namespace dnn { //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; diff --git a/tests/darknet/yolo4tiny.cpp b/tests/darknet/yolo4tiny.cpp index 44fbac8..9a65f30 100644 --- a/tests/darknet/yolo4tiny.cpp +++ b/tests/darknet/yolo4tiny.cpp @@ -26,8 +26,15 @@ 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(); + std::cout<<"DELETING NET"<destroy(); delete netRT; + + std::cout<<"RETRUNING RET"< Date: Sun, 5 Sep 2021 01:06:56 +0530 Subject: [PATCH 10/58] tkDNN can now deserialize tensorrt-8 engine (both through test_* and trtexec) but demo has issues in yolo::computeDetections --- CMakeLists.txt | 10 +- include/tkDNN/NetworkRT.h | 53 +-- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 162 ++----- .../tkDNN/pluginsRT/ActivationLogisticRT.h | 160 ++----- include/tkDNN/pluginsRT/ActivationMishRT.h | 148 ++---- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 166 ++----- include/tkDNN/pluginsRT/DeformableConvRT.h | 421 ++++-------------- include/tkDNN/pluginsRT/FlattenConcatRT.h | 181 +++----- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 215 +++------ include/tkDNN/pluginsRT/RegionRT.h | 223 +++------- include/tkDNN/pluginsRT/ReorgRT.h | 178 +++----- include/tkDNN/pluginsRT/ReshapeRT.h | 183 +++----- include/tkDNN/pluginsRT/ResizeLayerRT.h | 206 +++------ include/tkDNN/pluginsRT/RouteRT.h | 215 +++------ include/tkDNN/pluginsRT/ShortcutRT.h | 204 +++------ include/tkDNN/pluginsRT/UpsampleRT.h | 189 +++----- include/tkDNN/pluginsRT/YoloRT.h | 323 ++++---------- include/tkDNN/utils.h | 13 + src/DarknetParser.cpp | 9 +- src/Yolo.cpp | 5 +- src/pluginsRT/ActivationLeakyRT.cpp | 138 ++++++ src/pluginsRT/ActivationLogisticRT.cpp | 126 ++++++ src/pluginsRT/ActivationMishRT.cpp | 121 +++++ src/pluginsRT/ActivationReLUCeilingRT.cpp | 129 ++++++ src/pluginsRT/DeformableConvRT.cpp | 331 ++++++++++++++ src/pluginsRT/FlattenConcatRT.cpp | 163 +++++++ src/pluginsRT/MaxPoolingSizeRT.cpp | 179 ++++++++ src/pluginsRT/RegionRT.cpp | 174 ++++++++ src/pluginsRT/ReorgRT.cpp | 151 +++++++ src/pluginsRT/ReshapeRT.cpp | 152 +++++++ src/pluginsRT/ResizeLayerRT.cpp | 163 +++++++ src/pluginsRT/RouteRT.cpp | 183 ++++++++ src/pluginsRT/ShortcutRT.cpp | 167 +++++++ src/pluginsRT/UpsampleRT.cpp | 155 +++++++ src/pluginsRT/YoloRT.cpp | 253 +++++++++++ 35 files changed, 3527 insertions(+), 2322 deletions(-) create mode 100644 src/pluginsRT/ActivationLeakyRT.cpp create mode 100644 src/pluginsRT/ActivationLogisticRT.cpp create mode 100644 src/pluginsRT/ActivationMishRT.cpp create mode 100644 src/pluginsRT/ActivationReLUCeilingRT.cpp create mode 100644 src/pluginsRT/DeformableConvRT.cpp create mode 100644 src/pluginsRT/FlattenConcatRT.cpp create mode 100644 src/pluginsRT/MaxPoolingSizeRT.cpp create mode 100644 src/pluginsRT/RegionRT.cpp create mode 100644 src/pluginsRT/ReorgRT.cpp create mode 100644 src/pluginsRT/ReshapeRT.cpp create mode 100644 src/pluginsRT/ResizeLayerRT.cpp create mode 100644 src/pluginsRT/RouteRT.cpp create mode 100644 src/pluginsRT/ShortcutRT.cpp create mode 100644 src/pluginsRT/UpsampleRT.cpp create mode 100644 src/pluginsRT/YoloRT.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 9200b8c..f3471e2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,7 +31,7 @@ endif() 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 -G -g) +set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) find_package(CUDNN REQUIRED) @@ -39,8 +39,10 @@ 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_LIBRAY} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) @@ -64,11 +66,11 @@ find_package(yaml-cpp REQUIRED) # Build Libraries #------------------------------------------------------------------------------- file(GLOB tkdnn_SRC "src/*.cpp") -set(tkdnn_LIBS ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) +set(tkdnn_LIBS kernels ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${OPENCV_INCLUDE_DIRS} ${NVINFER_INCLUDES}) -cuda_add_library(tkDNN SHARED ${tkdnn_SRC} ${tkdnn_CUSRC}) +add_library(tkDNN SHARED ${tkdnn_SRC}) target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRAY}) #static diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 95ecb5e..94a60f3 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -8,48 +8,25 @@ #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 : IPlugin -{ -public: - YoloRT *yolos[16]; - int n_yolos; - - virtual IPlugin* createPlugin(const char* layerName, const void* serialData, size_t serialLength); -};*/ diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index e73ca2b..ae395ef 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -1,148 +1,84 @@ +#include "NvInfer.h" #include "../kernels.h" #include +#include -class ActivationLeakyRT : public IPluginV2 { +namespace nvinfer1 { + class ActivationLeakyRT : public IPluginV2 { -public: - ActivationLeakyRT(float s) { slope = s; } + public: + explicit ActivationLeakyRT(float s); - ActivationLeakyRT(const void *data, size_t length) - { - std::cout<<"DESERIALIZE LEAKYRT"<(data),*bufCheck = buf; - slope = readBUF(buf); - size = readBUF(buf); - assert(buf == bufCheck + length); + ActivationLeakyRT(const void *data, size_t length); - } + ~ActivationLeakyRT(); - ~ActivationLeakyRT() {} + int getNbOutputs() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override { return 1; } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + void + configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override - { - assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - size = 1; - for (int i = 0; i < outputDims[0].nbDims; i++) - size *= outputDims[0].d[i]; - } + int initialize() NOEXCEPT override; - int initialize() NOEXCEPT override { return 0; } + void terminate() NOEXCEPT override {} - virtual void terminate() NOEXCEPT override {} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { - return 0; - } + int enqueue(int batchSize, void const *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - virtual int enqueue(int batchSize, void const *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - activationLEAKYForward( - (dnnType *) reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize * size, slope, - stream); - return 0; - } + size_t getSerializationSize() const NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1 * sizeof(int) + 1 * sizeof(float); - } + void serialize(void *buffer) const NOEXCEPT override; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { - return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - } + const char *getPluginType() const NOEXCEPT override; - const char *getPluginType() const NOEXCEPT override { - return "ActivationLeakyRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + void destroy() NOEXCEPT override; - void destroy() NOEXCEPT override { delete this; } + const char *getPluginNamespace() const NOEXCEPT override; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + IPluginV2 *clone() const NOEXCEPT override; - IPluginV2* clone() const NOEXCEPT override { - ActivationLeakyRT *p = new ActivationLeakyRT(slope); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + int size; + float slope; - int size; - float slope; + private: + std::string mPluginNamespace; + }; -private: - std::string mPluginNamespace; -}; + class ActivationLeakyRTPluginCreator : public IPluginCreator { + public: + ActivationLeakyRTPluginCreator(); -class ActivationLeakyRTPluginCreator : public IPluginCreator { -public: - ActivationLeakyRTPluginCreator() { - mPluginAttributes.emplace_back( - PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { - ActivationLeakyRT *pluginObj = new ActivationLeakyRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { - const PluginField *fields = fc->fields; - assert(fc->nbFields == 1); - assert(fields[0].type == PluginFieldType::kFLOAT32); - float slope = *(static_cast(fields[0].data)); - ActivationLeakyRT *pluginObj = new ActivationLeakyRT(slope); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginName() const NOEXCEPT override ; - const char *getPluginName() const NOEXCEPT override{ - return "ActivationLeakyRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override; - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; -REGISTER_TENSORRT_PLUGIN(ActivationLeakyRTPluginCreator); \ No newline at end of file + 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 e40e7b4..9646efc 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -1,147 +1,83 @@ #include #include "../kernels.h" +#include +#include +#include -class ActivationLogisticRT : public IPluginV2 { +namespace nvinfer1 { -public: - ActivationLogisticRT() { + class ActivationLogisticRT : public IPluginV2 { - } + public: + ActivationLogisticRT() ; - ActivationLogisticRT(const void *data, size_t length) - { - const char* buf = reinterpret_cast(data),*bufCheck = buf; - size = readBUF(buf); - assert(buf == bufCheck + length); + ActivationLogisticRT(const void *data, size_t length) ; - } + ~ActivationLogisticRT() ; - ~ActivationLogisticRT(){ + int getNbOutputs() const NOEXCEPT override ; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + int initialize() NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - size = 1; - for(int i=0; i(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, stream); - return 0; - } + const char *getPluginVersion() const NOEXCEPT override ; + void destroy() NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1*sizeof(int); - } + const char *getPluginNamespace() const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer); - tk::dnn::writeBUF(buf, size); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override { - return "ActivationLogisticRT_tkDNN"; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + IPluginV2 *clone() const NOEXCEPT override ; - void destroy() NOEXCEPT override { delete this; } + int size; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + private: + std::string mPluginNamespace; + }; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + class ActivationLogisticRTPluginCreator : public IPluginCreator { + public: + ActivationLogisticRTPluginCreator() ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override{ - ActivationLogisticRT *p = new ActivationLogisticRT(); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - int size; + const char *getPluginNamespace() const NOEXCEPT override ; -private: - std::string mPluginNamespace; -}; + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; -class ActivationLogisticRTPluginCreator : public IPluginCreator{ -public: - ActivationLogisticRTPluginCreator(){ - mPluginAttributes.clear(); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + const char *getPluginVersion() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { - ActivationLogisticRT *pluginObj = new ActivationLogisticRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginName() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { - ActivationLogisticRT *pluginObj = new ActivationLogisticRT(); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ActivationLogisticRT_tkDNN"; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ActivationLogisticRTPluginCreator); \ No newline at end of file + 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 65153d0..3c9f15a 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -1,135 +1,79 @@ #include #include "../kernels.h" +#include +#include -class ActivationMishRT : public IPluginV2 { +namespace nvinfer1 { + class ActivationMishRT : public IPluginV2 { -public: - ActivationMishRT() {} + public: + ActivationMishRT() ; - ~ActivationMishRT() {} + ~ActivationMishRT() ; - ActivationMishRT(const void *data, size_t length) { - std::cout<<"DESERIALIZE MISH"<(data), *bufCheck = buf; - size = readBUF(buf); - assert(buf == bufCheck + length); - } + ActivationMishRT(const void *data, size_t length) ; - int getNbOutputs() const NOEXCEPT override { return 1; } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } + 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 { - assert(format == PluginFormat::kLINEAR); - size = 1; - for (int i = 0; i < outputDims[0].nbDims; i++) - size *= outputDims[0].d[i]; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override { return 0; } + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0; } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - activationMishForward((dnnType *) reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize * size, stream); - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; + size_t getSerializationSize() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1 * sizeof(int); - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override { - return "ActivationMishRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + void destroy() NOEXCEPT override { delete this; } - void destroy() NOEXCEPT override { delete this; } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override ; - void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override { - mPluginNamespace = plguinNamespace; - } + IPluginV2 *clone() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override { - ActivationMishRT *p = new ActivationMishRT(); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + int size; + private: + std::string mPluginNamespace; + }; - int size; -private: - std::string mPluginNamespace; -}; + class ActivationMishRTPluginCreator : public IPluginCreator { + public: + ActivationMishRTPluginCreator() ; -class ActivationMishRTPluginCreator : public IPluginCreator { -public: - ActivationMishRTPluginCreator() { - mPluginAttributes.clear(); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + const char *getPluginNamespace() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - ActivationMishRT *pluginObj = new ActivationMishRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginName() const NOEXCEPT override ; - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - ActivationMishRT *pluginObj = new ActivationMishRT(); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginName() const NOEXCEPT override{ - return "ActivationMishRT_tkDNN"; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ActivationMishRTPluginCreator); \ No newline at end of file + 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 8d295df..b5c186c 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -1,150 +1,78 @@ #include #include "../kernels.h" +#include +#include +#include +namespace nvinfer1 { + class ActivationReLUCeiling : public IPluginV2 { -class ActivationReLUCeiling : public IPluginV2 { + public: + explicit ActivationReLUCeiling(const float ceiling) ; -public: - ActivationReLUCeiling(const float ceiling) { - this->ceiling = ceiling; - } + ~ActivationReLUCeiling() ; - ~ActivationReLUCeiling() { + ActivationReLUCeiling(const void *data, size_t length) ; - } + int getNbOutputs() const NOEXCEPT override ; - ActivationReLUCeiling(const void *data, size_t length) { - std::cout<<"RELU CEILING DESERIALIZE"<(data), *bufCheck = buf; - ceiling = readBUF(buf); - size = readBUF(buf); - assert(buf == bufCheck + length); - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + int initialize() NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override { - assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - size = 1; - for (int i = 0; i < outputDims[0].nbDims; i++) - size *= outputDims[0].d[i]; - } + void terminate() NOEXCEPT override ; - int initialize() NOEXCEPT override { return 0; } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); - return 0; - } + void serialize(void *buffer) const NOEXCEPT override ; + IPluginV2 *clone() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1 * sizeof(int) + 1 * sizeof(float); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, ceiling); - tk::dnn::writeBUF(buf, size); - assert(buf = a + getSerializationSize()); + void destroy() NOEXCEPT override ; - } + const char *getPluginType() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override { - ActivationReLUCeiling *p = new ActivationReLUCeiling(ceiling); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + const char *getPluginVersion() const NOEXCEPT override ; - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { - return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - } + const char *getPluginNamespace() const NOEXCEPT override ; - void destroy() NOEXCEPT override { delete this; }; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + int size; + float ceiling; + private: + std::string mPluginNamespace; + }; - const char *getPluginType() const NOEXCEPT override { - return "ActivationReLUCeilingRT_tkDNN"; - } + class ActivationReLUCeilingPluginCreator : public IPluginCreator { + public: + ActivationReLUCeilingPluginCreator() ; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + const char *getPluginNamespace() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - int size; - float ceiling; -private: - std::string mPluginNamespace; -}; + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; -class ActivationReLUCeilingPluginCreator : public IPluginCreator { -public: - ActivationReLUCeilingPluginCreator() { - mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + const char *getPluginName() const NOEXCEPT override ; + const char *getPluginVersion() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + public: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { - ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(serialData, serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - float ceiling = *(static_cast(fields[0].data)); - ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(ceiling); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ActivationReLUCeilingRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -public: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ActivationReLUCeilingPluginCreator); + 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 7076379..adc5554 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -1,360 +1,115 @@ +#ifndef _DEFORMABLECONVRT_PLUGIN_H +#define _DEFORMABLECONVRT_PLUGIN_H + +#include +#include #include #include "../kernels.h" +#include -class DeformableConvRT : public IPluginV2 { +namespace nvinfer1 { + class DeformableConvRT : public IPluginV2 { + 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); -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; - this->defRT = deformable; + ~DeformableConvRT(); - 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) { - 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(const void *data, size_t length) ; - ~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 NOEXCEPT override ; - 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); - dnnType *aus = new dnnType[chunk_dim*2]; - for(int i=0;i(buf); - checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - aus = new dnnType[chunk_dim]; - for(int i=0;i(buf); - checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - aus = new dnnType[i_c*o_c*kh*kw*1]; - for(int i=0;i<(i_c*o_c*kh*kw*1);i++) - aus[i] = readBUF(buf); - checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); - free(aus); + int initialize() NOEXCEPT override ; - aus = new dnnType[o_c]; - for(int i=0; i < o_c; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); - free(aus); + void terminate() NOEXCEPT override ; - aus = new dnnType[height_ones * width_ones]; - for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); - free(aus); + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - aus = new dnnType[dim_ones]; - for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); - free(aus); + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - assert(buf == bufCheck + length); - } + size_t getSerializationSize() const NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override {return 1;} + void serialize(void *buffer) const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; - } + void destroy() NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + const char *getPluginNamespace() const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override { } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + const char *getPluginType() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); + const char *getPluginVersion() const NOEXCEPT override ; - // 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; - } - - virtual size_t getSerializationSize() const NOEXCEPT 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); - } - - virtual void serialize(void* buffer) const NOEXCEPT 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; isetPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override ; - cublasStatus_t stat; - cublasHandle_t handle; - 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; - - 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; - - - tk::dnn::DeformConv2d *defRT; + cublasStatus_t stat; + cublasHandle_t handle; + 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; + + 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; + + + tk::dnn::DeformConv2d *defRT; + + private: + std::string mPluginNamespace; + }; + + class DeformableConvRTPluginCreator : public IPluginCreator { + public: + DeformableConvRTPluginCreator(); + + 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; + }; -private: - std::string mPluginNamespace; }; - -class DeformableConvRTPluginCreator : public IPluginCreator{ -public: - DeformableConvRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - DeformableConvRT *pluginObj = new DeformableConvRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - 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[14].data)); - DeformConv2d *defRT = const_cast(static_cast(fields[15].data)); - DeformableConvRT *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,defRT); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "DeformableConvRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - - +#endif diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 3c6f3ee..7d655d3 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,162 +1,81 @@ #include +#include +#include +#include +namespace nvinfer1 { + class FlattenConcatRT : public IPluginV2 { -class FlattenConcatRT : public IPluginV2 { + public: + FlattenConcatRT() ; -public: - FlattenConcatRT() { - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) { - printf ("CUBLAS initialization failed\n"); - return; - } - } + FlattenConcatRT(const void *data, size_t length) ; - 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 getNbOutputs() const NOEXCEPT override ; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; - } + int initialize() NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT 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() NOEXCEPT override {return 0;} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override { checkERROR(cublasDestroy(handle));} + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override {return 0;} + size_t getSerializationSize() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT 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 *getPluginType() const NOEXCEPT override ; - void destroy() NOEXCEPT override{delete this;} + const char *getPluginVersion() const NOEXCEPT override; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "FlattenConcatRT_tkDNN"; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + IPluginV2 *clone() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + int c, h, w; + int rows, cols; + cublasStatus_t stat; + cublasHandle_t handle; + private: + std::string mPluginNamespace; + }; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + class FlattenConcatRTPluginCreator : public IPluginCreator { + public: + FlattenConcatRTPluginCreator() ; - IPluginV2 *clone() const NOEXCEPT override { - FlattenConcatRT *p = new FlattenConcatRT(); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - int c, h, w; - int rows, cols; - cublasStatus_t stat; - cublasHandle_t handle; -private: - std::string mPluginNamespace; -}; + const char *getPluginNamespace() const NOEXCEPT override ; -class FlattenConcatRTPluginCreator : public IPluginCreator{ -public: - FlattenConcatRTPluginCreator(){ - mPluginAttributes.clear(); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginName() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - FlattenConcatRT *pluginObj = new FlattenConcatRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginVersion() const NOEXCEPT override; - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - FlattenConcatRT *pluginObj = new FlattenConcatRT(); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - const char *getPluginName() const NOEXCEPT override{ - return "FlattenConcatRT_tkDNN"; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(FlattenConcatRTPluginCreator); \ No newline at end of file + 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 ef5a8f7..14f714e 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -1,182 +1,89 @@ #include #include "../kernels.h" +#include +#include +#include -class MaxPoolFixedSizeRT : public IPluginV2 { +namespace nvinfer1 { + class MaxPoolFixedSizeRT : public IPluginV2 { -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; - } + public: + MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) ; - 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(const void *data, size_t length) ; - ~MaxPoolFixedSizeRT(){ - } + ~MaxPoolFixedSizeRT() ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{this->c, this->h, this->w}; - } + 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 { - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT 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; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 8*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; + void serialize(void *buffer) const NOEXCEPT override ; - 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()); - } + void destroy() NOEXCEPT override ; - void destroy() NOEXCEPT override{delete this;} + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - const char *getPluginType() const NOEXCEPT override{ - return "MaxPoolingFixedSizeRT_tkDNN"; - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + const char *getPluginVersion() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override{ - MaxPoolFixedSizeRT *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override ; - int n, c, h, w; - int stride_H, stride_W; - int winSize; - int padding; + int n, c, h, w; + int stride_H, stride_W; + int winSize; + int padding; -private: - std::string mPluginNamespace; + private: + std::string mPluginNamespace; + }; + + class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator { + public: + MaxPoolFixedSizeRTPluginCreator() ; + + 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(MaxPoolFixedSizeRTPluginCreator); }; - -class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator{ -public: - MaxPoolFixedSizeRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - //todo assert - 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)); - MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "MaxPoolingFixedSizeRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - 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 e187d6c..cdcb515 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -1,188 +1,95 @@ +#ifndef _REGIONRT_PLUGIN_H +#define _REGIONRT_PLUGIN_H #include #include "../kernels.h" +#include +#include +#include -class RegionRT : public IPluginV2 { +namespace nvinfer1 { + class RegionRT : public IPluginV2 { -public: - RegionRT(int classes, int coords, int num) { - this->classes = classes; - this->coords = coords; - this->num = num; - } + public: + RegionRT(int classes, int coords, int num); - ~RegionRT(){ + ~RegionRT() ; - } + RegionRT(const void *data, size_t length) ; - 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 getNbOutputs() const NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } - - int initialize() NOEXCEPT override { return 0; } + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override { } + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0; } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT 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 enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 6*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT 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()); - } + void serialize(void *buffer) const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "RegionRT_tkDNN"; - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + const char *getPluginVersion() const NOEXCEPT override ; - void destroy() NOEXCEPT override {delete this;} + void destroy() NOEXCEPT override ; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginNamespace() const NOEXCEPT override ; - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - IPluginV2* clone() const NOEXCEPT override{ - RegionRT *p = new RegionRT(classes,coords,num); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override ; + int c, h, w; + int classes, coords, num; - 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; + } - 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; + }; -private: - std::string mPluginNamespace; + class RegionRTPluginCreator : public IPluginCreator { + public: + RegionRTPluginCreator(); + + 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(RegionRTPluginCreator); }; -class RegionRTPluginCreator : public IPluginCreator{ -public: - RegionRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ - RegionRT *pluginObj = new RegionRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); - int classes = *(static_cast(fields[0].data)); - int coords = *(static_cast(fields[1].data)); - int num = *(static_cast(fields[2].data)); - RegionRT *pluginObj = new RegionRT(classes,coords,num); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - - } - - const char *getPluginName() const NOEXCEPT override{ - return "RegionRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -private: - PluginFieldCollection mFC; - 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 7605fde..a780615 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -1,143 +1,83 @@ #include #include "../kernels.h" +#include +#include -class ReorgRT : public IPluginV2 { +namespace nvinfer1 { + class ReorgRT : public IPluginV2 { -public: - ReorgRT(int stride) { - this->stride = stride; - } + public: + ReorgRT(int stride); - ~ReorgRT(){ + ~ReorgRT(); - } + ReorgRT(const void *data, size_t length); - 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 getNbOutputs() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override {return 1;} + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; - } + void + configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + int initialize() NOEXCEPT override; - int initialize() NOEXCEPT override { return 0;} + void terminate() NOEXCEPT override; - virtual void terminate() NOEXCEPT override {} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - - reorgForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), - batchSize, c, h, w, stride, stream); - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 4*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override; - virtual void serialize(void* buffer) const NOEXCEPT 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()); - } - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{return true;} + void serialize(void *buffer) const NOEXCEPT override; - const char *getPluginType() const NOEXCEPT override{ - return "ReorgRT_tkDNN"; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - const char* getPluginVersion() const NOEXCEPT override{ - return "1"; - } - void destroy() NOEXCEPT override{ delete this;} + const char *getPluginType() const NOEXCEPT override; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginVersion() const NOEXCEPT override; - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + void destroy() NOEXCEPT override; - IPluginV2* clone() const NOEXCEPT override{ - ReorgRT *p = new ReorgRT(stride); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + const char *getPluginNamespace() const NOEXCEPT override; - int c, h, w, stride; -private: - std::string mPluginNamespace; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2 *clone() const 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; + + 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(ReorgRTPluginCreator); }; -class ReorgRTPluginCreator : public IPluginCreator{ -public: - ReorgRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2* deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - ReorgRT *pluginObj = new ReorgRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection* fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 1); - assert(fields[0].type == PluginFieldType::kINT32); - int stride = *(static_cast(fields[0].data)); - ReorgRT *pluginObj = new ReorgRT(stride); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ReorgRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -private: - PluginFieldCollection mFC; - 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 17037da..8d3fdb5 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -1,148 +1,85 @@ +#ifndef _RESHAPERT_PLUGIN_H +#define _RESHAPERT_PLUGIN_H + #include +#include +#include +#include +using namespace tk::dnn; -class ReshapeRT : public IPluginV2 { -public: - ReshapeRT(dataDim_t newDim) { - new_dim = newDim; - n = new_dim.n; - c = new_dim.c; - h = new_dim.h; - w = new_dim.w; - } +namespace nvinfer1 { + class ReshapeRT : public IPluginV2 { - ReshapeRT(const void *data,size_t length){ - const char *buf = reinterpret_cast(data),*bufCheck = buf; - new_dim.n = readBUF(buf); - new_dim.c = readBUF(buf); - new_dim.h = readBUF(buf); - new_dim.w = readBUF(buf); - assert(buf == bufCheck + length); - } + public: + explicit ReshapeRT(dataDim_t newDim) ; - ~ReshapeRT(){ + ReshapeRT(const void *data, size_t length) ; - } + ~ReshapeRT() ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{ c,h,w}; - } + 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 { - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 4*sizeof(int); - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT 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()); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "1"; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "ReshapeRT_tkDNN"; - } + void destroy() NOEXCEPT override ; - void destroy() NOEXCEPT override{delete this;} + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + IPluginV2 *clone() const NOEXCEPT override ; + int n, c, h, w; + dataDim_t new_dim; + private: + std::string mPluginNamespace; + }; - IPluginV2 *clone() const NOEXCEPT override{ - ReshapeRT *p = new ReshapeRT(new_dim); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + class ReshapeRTPluginCreator : public IPluginCreator { + public: + ReshapeRTPluginCreator() ; - int n, c, h, w; - dataDim_t new_dim; -private: - std::string mPluginNamespace; + 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(ReshapeRTPluginCreator); }; - -class ReshapeRTPluginCreator : public IPluginCreator{ -public: - ReshapeRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ - ReshapeRT *pluginObj = new ReshapeRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - dataDim_t newDim = *(static_cast(fields[0].data)); - ReshapeRT *pluginObj = new ReshapeRT(newDim); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ReshapeRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - 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 374b7d8..7316048 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -1,165 +1,87 @@ #include #include "../kernels.h" +#include +#include +#include -class ResizeLayerRT : public IPluginV2 { +namespace nvinfer1 { -public: - ResizeLayerRT(int c, int h, int w) { - o_c = c; - o_h = h; - o_w = w; - } + class ResizeLayerRT : public IPluginV2 { - 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); - } + public: + ResizeLayerRT(int c, int h, int w) ; - ~ResizeLayerRT(){ - } + ResizeLayerRT(const void *data, size_t length) ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + ~ResizeLayerRT() ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{o_c, o_h, o_w}; - } + int getNbOutputs() const NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - i_c = inputDims[0].d[0]; - i_h = inputDims[0].d[1]; - i_w = inputDims[0].d[2]; - } - - int initialize() NOEXCEPT override {return 0;} - - virtual void terminate() NOEXCEPT override {} - - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT 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; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 6*sizeof(int); - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; + int initialize() NOEXCEPT override ; - tk::dnn::writeBUF(buf, o_c); - tk::dnn::writeBUF(buf, o_h); - tk::dnn::writeBUF(buf, o_w); + void terminate() NOEXCEPT override ; - tk::dnn::writeBUF(buf, i_c); - tk::dnn::writeBUF(buf, i_h); - tk::dnn::writeBUF(buf, i_w); - assert(buf == a + getSerializationSize()); - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "ResizeLayerRT_tkDNN"; - } - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - void destroy() NOEXCEPT override{delete this;} + size_t getSerializationSize() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + void serialize(void *buffer) const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - IPluginV2 *clone() const NOEXCEPT override{ - ResizeLayerRT *p = new ResizeLayerRT(o_c,o_h,o_w); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - int i_c, i_h, i_w, o_c, o_h, o_w; + const char *getPluginType() const NOEXCEPT override ; -private: - std::string mPluginNamespace; + 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 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 ; + + 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(ResizeLayerRTPluginCreator); }; -class ResizeLayerRTPluginCreator : public IPluginCreator{ -public: - ResizeLayerRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - ResizeLayerRT *pluginObj = new ResizeLayerRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); - int oc = *(static_cast(fields[0].data)); - int oh = *(static_cast(fields[1].data)); - int ow = *(static_cast(fields[2].data)); - ResizeLayerRT *pluginObj = new ResizeLayerRT(oc,oh,ow); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ResizeLayerRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; - -}; - -REGISTER_TENSORRT_PLUGIN(ResizeLayerRTPluginCreator); - diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 2ceede3..2b9bc67 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -1,181 +1,86 @@ #include #include "../kernels.h" +#include +#include -class RouteRT : public IPluginV2 { +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) ; - 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 getNbOutputs() const NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - int out_c = 0; - for(int i=0; i(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; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return (6+MAX_INPUTS)*sizeof(int); - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT 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; isetPluginNamespace(mPluginNamespace.c_str()); - return p; - } - static const int MAX_INPUTS = 4; - int in; - int c_in[MAX_INPUTS]; - int c, h, w; - int groups, group_id; -private: - std::string mPluginNamespace; + class RouteRTPluginCreator : public IPluginCreator { + public: + RouteRTPluginCreator() ; + + 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(RouteRTPluginCreator); }; - -class RouteRTPluginCreator : public IPluginCreator{ -public: - RouteRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - RouteRT *pluginObj = new RouteRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - 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 *getPluginName() const NOEXCEPT override{ - return "RouteRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(RouteRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 9f3d343..7069180 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -1,166 +1,94 @@ +#ifndef _SHORTCUTRT_PLUGIN_H +#define _SHORTCUTRT_PLUGIN_H + #include #include "../kernels.h" +#include +#include +#include -class ShortcutRT : public IPluginV2 { +namespace nvinfer1 { -public: - ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - bDim = bdim; - this->bc = bDim.c; - this->bh = bDim.h; - this->bw = bDim.w; - this->mul = mul; - } + class ShortcutRT : public IPluginV2 { - ~ShortcutRT(){} + public: + ShortcutRT(tk::dnn::dataDim_t bdim, bool mul); - ShortcutRT(const void* data,size_t length){ - const char* buf =reinterpret_cast(data),*bufCheck = buf; - bDim.c = readBUF(buf); - bDim.h = readBUF(buf); - bDim.w = readBUF(buf); - bDim.l = 1; - mul = readBUF(buf); - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - assert(buf == bufCheck + length); - } + ~ShortcutRT(); - int getNbOutputs() const NOEXCEPT override {return 1;} + ShortcutRT(const void *data, size_t length); - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; - } + int getNbOutputs() const NOEXCEPT override; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT 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() NOEXCEPT override {return 0;} + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - virtual void terminate() NOEXCEPT override {} + int initialize() NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + void terminate() NOEXCEPT override; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT 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; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 6*sizeof(int) + sizeof(bool); - } + size_t getSerializationSize() const NOEXCEPT override; - virtual void serialize(void* buffer) const NOEXCEPT 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()); - - } + void serialize(void *buffer) const NOEXCEPT override; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - const char* getPluginType() const NOEXCEPT override{ - return "1"; - } + const char *getPluginType() const NOEXCEPT override; - const char* getPluginVersion() const NOEXCEPT override{ - return "ShortcutRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override; - void destroy() NOEXCEPT override{delete this;} + void destroy() NOEXCEPT override; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginNamespace() const NOEXCEPT override; - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override{ - ShortcutRT *p = new ShortcutRT(bDim,mul); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override; + + int c, h, w; + int bc, bh, bw; + 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; + + 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(ShortcutRTPluginCreator); - int c, h, w; - int bc, bh, bw; - bool mul; - tk::dnn::dataDim_t bDim; -private: - std::string mPluginNamespace; }; - -class ShortcutRTPluginCreator : public IPluginCreator { -public: - ShortcutRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - ShortcutRT *pluginObj = new ShortcutRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - //todo assert - tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); - bool mul = *(static_cast(fields[1].data)); - ShortcutRT *pluginObj = new ShortcutRT(bdim,mul); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ShortcutRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -public: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ShortcutRTPluginCreator); \ No newline at end of file +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 9d7a62c..030fe5a 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -1,150 +1,87 @@ +#ifndef _UPSAMPLERT_PLUGIN_H +#define _UPSAMPLERT_PLUGIN_H + #include #include "../kernels.h" +#include +#include + +namespace nvinfer1 { + + class UpsampleRT : public IPluginV2 { + + public: + explicit UpsampleRT(int stride); + + UpsampleRT(const void *data, size_t length); + + ~UpsampleRT(); + + 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; + + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; -class UpsampleRT : public IPluginV2 { + size_t getSerializationSize() const NOEXCEPT override; -public: - UpsampleRT(int stride) { - this->stride = stride; - } + void serialize(void *buffer) const NOEXCEPT override; - 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); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + const char *getPluginType() const NOEXCEPT override; - ~UpsampleRT(){} + const char *getPluginVersion() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void destroy() NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); - } + const char *getPluginNamespace() const NOEXCEPT override; - void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - int initialize() NOEXCEPT override {return 0;} + IPluginV2 *clone() const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + int c, h, w, stride; + private: + std::string mPluginNamespace; + }; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + class UpsampleRTPluginCreator : public IPluginCreator { + public: + UpsampleRTPluginCreator(); - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT 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; - } + const char *getPluginNamespace() const NOEXCEPT override; + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int);} + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; - virtual void serialize(void* buffer) const NOEXCEPT 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()); - } + const char *getPluginName() const NOEXCEPT override; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - //todo assert - return true; - } + const char *getPluginVersion() const NOEXCEPT override; - const char *getPluginType() const NOEXCEPT override{ - return "1"; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override; - const char *getPluginVersion() const NOEXCEPT override{ - static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; - return UPSAMPLE_RT_PLUGIN; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - void destroy() NOEXCEPT override{delete this;} - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - IPluginV2* clone() const NOEXCEPT override{ - UpsampleRT *p = new UpsampleRT(stride); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } - - int c, h, w, stride; -private: - std::string mPluginNamespace; -}; - -class UpsampleRTPluginCreator : public IPluginCreator{ -public: - UpsampleRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - UpsampleRT *pluginObj = new UpsampleRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - int stride = *(static_cast(fields[0].data)); - UpsampleRT *pluginObj = new UpsampleRT(stride); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; - return UPSAMPLE_RT_PLUGIN; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); + 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 7ae7b35..0d895e0 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,282 +1,109 @@ +#ifndef _YOLORT_PLUGIN_H +#define _YOLORT_PLUGIN_H + #include #include #include "../kernels.h" +#include +#include + #define YOLORT_CLASSNAME_W 256 +namespace nvinfer1 { + class YoloRT : public IPluginV2 { -class YoloRT : public IPluginV2 { + 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); -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) { - this->yolo = Yolo; - 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(const void *data, size_t length); - 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; - } - } - - YoloRT(const void *data,size_t length){ - std::vector maskTemp,biasTemp; - std::cout<<"LENGTH : "<(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); - for(int i=0;i(buf)); - std::cout<(buf)); - std::cout<(buf); - classesNames[1] = std::string(tmp); - } - assert(buf == bufCheck + length); - - } - - ~YoloRT() { - - } + ~YoloRT(); + int getNbOutputs() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + int initialize() NOEXCEPT override; - int initialize() NOEXCEPT override { + void terminate() NOEXCEPT override; - return 0; - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual void terminate() NOEXCEPT override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { - return 0; - } - - virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT 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)); + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) 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 + size_t getSerializationSize() const NOEXCEPT override; - if (this->scaleXY != 1) - scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - index = entry_index(b, n * w * h, 4); - activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); - } - } + 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; + + IPluginV2 *clone() const NOEXCEPT override; + + tk::dnn::Yolo *yolo; + 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; + + dnnType *mask; + dnnType *bias; + + 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() const NOEXCEPT 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(); - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { - return true; //todo implement proper supportsFormat - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - virtual void serialize(void *buffer) const NOEXCEPT 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; - std::cout<setPluginNamespace(mPluginNamespace.c_str()); - return p; - } - - Yolo *yolo; - 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; - - dnnType *mask; - dnnType *bias; - - 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; - } - -private: - std::string mPluginNamespace; + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + REGISTER_TENSORRT_PLUGIN(YoloRTPluginCreator); }; - -class YoloRTPluginCreator : public IPluginCreator{ -public: - YoloRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - YoloRT *pluginObj = new YoloRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - //todo assert - int classes = *(static_cast(fields[0].data)); - int num = *(static_cast(fields[1].data)); - Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); - int numMasks = *(static_cast(fields[3].data)); - float scaleXY = *(static_cast(fields[4].data)); - float nmsThresh = *(static_cast(fields[5].data)); - int nmsKind = *(static_cast(fields[6].data)); - int newCoords = *(static_cast(fields[7].data)); - YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "YoloRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - 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 017cf1d..1219ec3 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -34,6 +34,19 @@ #define dnnType float +template void writeBUF(char*& buffer, const T& val) +{ + *reinterpret_cast(buffer) = val; + buffer += sizeof(T); +} + +template T readBUF(const char*& buffer) +{ + T val = *reinterpret_cast(buffer); + buffer += sizeof(T); + return val; +} + // Colored output #define COL_END "\033[0m" diff --git a/src/DarknetParser.cpp b/src/DarknetParser.cpp index a370b91..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; } @@ -322,7 +322,7 @@ namespace tk { namespace dnn { // skip empty lines if(line.empty()) continue; - if(count > lineNo && count <=20){ + if(count > lineNo && count <=lineNo+30){ divideNameAndValue(line,name,value); if(name == "mask "){ maskTemp = fromStringToFloatVec(value,','); @@ -353,9 +353,8 @@ namespace tk { namespace dnn { if(name == "beta_nms"){ nmsThreshTemp = std::stof(value); } - - count++; } + count++; } mask = maskTemp; anchors = anchorsTemp; diff --git a/src/Yolo.cpp b/src/Yolo.cpp index deffbeb..35abb19 100644 --- a/src/Yolo.cpp +++ b/src/Yolo.cpp @@ -133,10 +133,11 @@ 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()]; + checkCuda(cudaDeviceSynchronize()); checkCuda( cudaMemcpy(predictions, dstData, output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost)); int lw = output_dim.w; @@ -157,7 +158,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/pluginsRT/ActivationLeakyRT.cpp b/src/pluginsRT/ActivationLeakyRT.cpp new file mode 100644 index 0000000..77063f6 --- /dev/null +++ b/src/pluginsRT/ActivationLeakyRT.cpp @@ -0,0 +1,138 @@ +#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; +} + +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; + +} + +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.emplace_back( + PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); + 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..9966708 --- /dev/null +++ b/src/pluginsRT/ActivationLogisticRT.cpp @@ -0,0 +1,126 @@ +#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; +} + +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; +} + +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..7797df9 --- /dev/null +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -0,0 +1,121 @@ +// +// 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; } + +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; +} +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 true; +} + +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..80b5a74 --- /dev/null +++ b/src/pluginsRT/ActivationReLUCeilingRT.cpp @@ -0,0 +1,129 @@ +#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; +} + +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; +} + +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.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); + 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..417af8e --- /dev/null +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -0,0 +1,331 @@ +#include +using namespace nvinfer1; +using namespace tk::dnn; + +std::vector DeformableConvRTPluginCreator::mPluginAttributes; +PluginFieldCollection DeformableConvRTPluginCreator::mFC{}; + + +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, + tk::dnn::DeformConv2d *deformable) { + 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->defRT = deformable; + + 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) { + 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::~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); +} + +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); + dnnType *aus = new dnnType[chunk_dim*2]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[chunk_dim]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[i_c*o_c*kh*kw*1]; + for(int i=0;i<(i_c*o_c*kh*kw*1);i++) + aus[i] = readBUF(buf); + checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[o_c]; + for(int i=0; i < o_c; i++) + aus[i] = readBUF(buf); + checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[height_ones * width_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[dim_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); + free(aus); + + assert(buf == bufCheck + length); + +} + +int DeformableConvRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims DeformableConvRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; +} + +void DeformableConvRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} + +int DeformableConvRT::initialize() NOEXCEPT { + return 0; +} + +void DeformableConvRT::terminate() NOEXCEPT {} + +size_t DeformableConvRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT {return 0;} + +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; +} + +size_t DeformableConvRT::getSerializationSize() const NOEXCEPT { + 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); +} + +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); + dnnType *aus = new dnnType[chunk_dim*2]; + checkCuda( cudaMemcpy(aus, offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToHost) ); + for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *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[14].data)); + auto *defRT = const_cast(static_cast(fields[15].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,defRT); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *DeformableConvRTPluginCreator::getPluginName() const NOEXCEPT { + return "DeformableConvRT_tkDNN"; +} + +const char *DeformableConvRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..51cebc5 --- /dev/null +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -0,0 +1,163 @@ +#include +using namespace nvinfer1; + +std::vector FlattenConcatRTPluginCreator::mPluginAttributes; +PluginFieldCollection FlattenConcatRTPluginCreator::mFC{}; + +FlattenConcatRT::FlattenConcatRT() { + stat = cublasCreate(&handle); + if (stat != CUBLAS_STATUS_SUCCESS) { + printf ("CUBLAS initialization failed\n"); + return; + } +} + +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}; +} + +void FlattenConcatRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + 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; +} + +int FlattenConcatRT::initialize() NOEXCEPT { + return 0; +} + +void FlattenConcatRT::terminate() NOEXCEPT { + checkERROR(cublasDestroy(handle)); +} + +size_t FlattenConcatRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +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(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; +} + +bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +const char *FlattenConcatRT::getPluginType() const NOEXCEPT { + return "FlattenConcatRT_tkDNN"; +} + +const char *FlattenConcatRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const char *FlattenConcatRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *FlattenConcatRT::clone() const NOEXCEPT { + auto *p = new FlattenConcatRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +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(); +} + +IPluginV2 *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; +} + +IPluginV2 *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + auto *pluginObj = new FlattenConcatRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *FlattenConcatRTPluginCreator::getPluginName() const NOEXCEPT { + return "FlattenConcatRT_tkDNN"; +} + +const char *FlattenConcatRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..4b95d7f --- /dev/null +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -0,0 +1,179 @@ +#include +using namespace nvinfer1; + +std::vector MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; +PluginFieldCollection MaxPoolFixedSizeRTPluginCreator::mFC{}; + +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}; +} + +void MaxPoolFixedSizeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} + +int MaxPoolFixedSizeRT::initialize() NOEXCEPT { + return 0; +} + +void MaxPoolFixedSizeRT::terminate() NOEXCEPT { + +} + +size_t MaxPoolFixedSizeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +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; +} + +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 true; + //todo assert +} + +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 "MaxPoolingFixedSizeRT_tkDNN"; +} + +const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +IPluginV2 *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; +} + + +MaxPoolFixedSizeRTPluginCreator::MaxPoolFixedSizeRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + //todo assert + 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 "MaxPoolingFixedSizeRT_tkDNN"; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..de1dd3b --- /dev/null +++ b/src/pluginsRT/RegionRT.cpp @@ -0,0 +1,174 @@ +#include +using namespace nvinfer1; +std::vector RegionRTPluginCreator::mPluginAttributes; +PluginFieldCollection RegionRTPluginCreator::mFC{}; + +RegionRT::RegionRT(int classes, int coords, int num) { + this->classes = classes; + this->coords = coords; + this->num = num; +} + +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]; +} + +void RegionRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int RegionRT::initialize() NOEXCEPT {return 0;} + +void RegionRT::terminate() NOEXCEPT {} + +size_t RegionRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +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; +} + +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_tkDNN"; +} + +const char *RegionRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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 true; +} + +IPluginV2 *RegionRT::clone() const NOEXCEPT { + auto *p = new RegionRT(classes,coords,num); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +RegionRTPluginCreator::RegionRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int classes = *(static_cast(fields[0].data)); + int coords = *(static_cast(fields[1].data)); + int num = *(static_cast(fields[2].data)); + RegionRT *pluginObj = new RegionRT(classes,coords,num); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *RegionRTPluginCreator::getPluginName() const NOEXCEPT { + return "RegionRT_tkDNN"; +} + +const char *RegionRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..d3dd12a --- /dev/null +++ b/src/pluginsRT/ReorgRT.cpp @@ -0,0 +1,151 @@ +#include +using namespace nvinfer1; + +std::vector ReorgRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReorgRTPluginCreator::mFC{}; + +ReorgRT::ReorgRT(int stride) { + this->stride = stride; +} + +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}; +} + +void ReorgRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int ReorgRT::initialize() NOEXCEPT { + return 0; +} + +void ReorgRT::terminate() NOEXCEPT {} + +size_t ReorgRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +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; +} + +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 true; +} + +const char *ReorgRT::getPluginType() const NOEXCEPT { + return "ReorgRT_tkDNN"; +} + +const char *ReorgRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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; +} + +IPluginV2 *ReorgRT::clone() const NOEXCEPT { + auto *p = new ReorgRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ReorgRTPluginCreator::ReorgRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kINT32); + int stride = *(static_cast(fields[0].data)); + auto *pluginObj = new ReorgRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReorgRTPluginCreator::getPluginName() const NOEXCEPT { + return "ReorgRT_tkDNN"; +} + +const char *ReorgRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..5e23ab3 --- /dev/null +++ b/src/pluginsRT/ReshapeRT.cpp @@ -0,0 +1,152 @@ +#include +using namespace nvinfer1; + +std::vector ReshapeRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReshapeRTPluginCreator::mFC{}; + +ReshapeRT::ReshapeRT(dataDim_t newDim) { + new_dim = newDim; + n = new_dim.n; + c = new_dim.c; + h = new_dim.h; + w = new_dim.w; +} + +ReshapeRT::ReshapeRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + new_dim.n = readBUF(buf); + new_dim.c = readBUF(buf); + new_dim.h = readBUF(buf); + new_dim.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} ; +} + +void ReshapeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} + +int ReshapeRT::initialize() NOEXCEPT { + return 0; +} + +void ReshapeRT::terminate() NOEXCEPT {} + +size_t ReshapeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +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; +} + +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 true; + //todo assert +} + +const char *ReshapeRT::getPluginType() const NOEXCEPT { + return "ReshapeRT_tkDNN"; +} + +const char *ReshapeRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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; +} + +IPluginV2 *ReshapeRT::clone() const NOEXCEPT { + auto *p = new ReshapeRT(new_dim); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ReshapeRTPluginCreator::ReshapeRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + dataDim_t newDim = *(static_cast(fields[0].data)); + ReshapeRT *pluginObj = new ReshapeRT(newDim); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReshapeRTPluginCreator::getPluginName() const NOEXCEPT { + return "ReshapeRT_tkDNN"; +} + +const char *ReshapeRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..12a3ff9 --- /dev/null +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -0,0 +1,163 @@ +#include +using namespace nvinfer1; + +std::vector ResizeLayerRTPluginCreator::mPluginAttributes; +PluginFieldCollection ResizeLayerRTPluginCreator::mFC{}; + + +ResizeLayerRT::ResizeLayerRT(int c, int h, int w) { + o_c = c; + o_h = h; + o_w = w; +} + +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}; +} + +void ResizeLayerRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + i_c = inputDims[0].d[0]; + i_h = inputDims[0].d[1]; + i_w = inputDims[0].d[2]; +} + +int ResizeLayerRT::initialize() NOEXCEPT { + return 0; +} + +void ResizeLayerRT::terminate() NOEXCEPT {} + +size_t ResizeLayerRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +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; +} + +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 true; + //todo assert +} + +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; +} + +IPluginV2 *ResizeLayerRT::clone() const NOEXCEPT { + auto *p = new ResizeLayerRT(o_c,o_h,o_w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ResizeLayerRTPluginCreator::ResizeLayerRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int oc = *(static_cast(fields[0].data)); + int oh = *(static_cast(fields[1].data)); + int ow = *(static_cast(fields[2].data)); + auto *pluginObj = new ResizeLayerRT(oc,oh,ow); + 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..87233a5 --- /dev/null +++ b/src/pluginsRT/RouteRT.cpp @@ -0,0 +1,183 @@ +#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(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; +} + +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.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); + 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..eb35bd6 --- /dev/null +++ b/src/pluginsRT/ShortcutRT.cpp @@ -0,0 +1,167 @@ +#include +using namespace nvinfer1; + +std::vector ShortcutRTPluginCreator::mPluginAttributes; +PluginFieldCollection ShortcutRTPluginCreator::mFC{}; + +ShortcutRT::ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { + bDim = bdim; + this->bc = bDim.c; + this->bh = bDim.h; + this->bw = bDim.w; + this->mul = mul; +} + +ShortcutRT::~ShortcutRT() {} + +ShortcutRT::ShortcutRT(const void *data, size_t length) { + const char* buf =reinterpret_cast(data),*bufCheck = buf; + bDim.c = readBUF(buf); + bDim.h = readBUF(buf); + bDim.w = readBUF(buf); + bDim.l = 1; + 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]}; +} + +void ShortcutRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int ShortcutRT::initialize() NOEXCEPT { + return 0; +} + +void ShortcutRT::terminate() NOEXCEPT {} + +size_t ShortcutRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +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; +} + +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 true; +} + +const char *ShortcutRT::getPluginType() const NOEXCEPT { + return "ShortcutRT_tkDNN"; +} + +const char *ShortcutRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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; +} + +IPluginV2 *ShortcutRT::clone() const NOEXCEPT { + auto *p = new ShortcutRT(bDim,mul); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ShortcutRTPluginCreator::ShortcutRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + //todo assert + tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); + bool mul = *(static_cast(fields[1].data)); + auto *pluginObj = new ShortcutRT(bdim,mul); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ShortcutRTPluginCreator::getPluginName() const NOEXCEPT { + return "ShortcutRT_tkDNN"; +} + +const char *ShortcutRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..044405b --- /dev/null +++ b/src/pluginsRT/UpsampleRT.cpp @@ -0,0 +1,155 @@ +#include +using namespace nvinfer1; + +std::vector UpsampleRTPluginCreator::mPluginAttributes; +PluginFieldCollection UpsampleRTPluginCreator::mFC{}; + +UpsampleRT::UpsampleRT(int stride) { + this->stride = stride; +} + +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); +} + +void UpsampleRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int UpsampleRT::initialize() NOEXCEPT { + return 0; +} + +void UpsampleRT::terminate() NOEXCEPT {} + +size_t UpsampleRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int UpsampleRT::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]); + + fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); + upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); + return 0; +} + +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 true; +} + +const char *UpsampleRT::getPluginType() const NOEXCEPT { + return "Upsample_tkDNN"; +} + +const char *UpsampleRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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; +} + +IPluginV2 *UpsampleRT::clone() const NOEXCEPT { + auto *p = new UpsampleRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +UpsampleRTPluginCreator::UpsampleRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int stride = *(static_cast(fields[0].data)); + auto *pluginObj = new UpsampleRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *UpsampleRTPluginCreator::getPluginName() const NOEXCEPT { + return "Upsample_tkDNN"; +} + +const char *UpsampleRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +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..7f615b4 --- /dev/null +++ b/src/pluginsRT/YoloRT.cpp @@ -0,0 +1,253 @@ +#include +using namespace nvinfer1; + +std::vector YoloRTPluginCreator::mPluginAttributes; +PluginFieldCollection YoloRTPluginCreator::mFC{}; + +YoloRT::YoloRT(int classes, int num, tk::dnn::Yolo *Yolo, int n_masks, float scale_xy, float nms_thresh, int nms_kind, + int new_coords) { + this->yolo = Yolo; + 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; + + 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; + } +} + +YoloRT::YoloRT(const void *data, size_t length) { + std::vector maskTemp,biasTemp; + std::cout<<"LENGTH : "<(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); + for(int i=0;i(buf)); + std::cout<(buf)); + std::cout<(buf); + classesNames[1] = std::string(tmp); + } + 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]; +} + +void YoloRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int YoloRT::initialize() NOEXCEPT { + return 0; +} + +void YoloRT::terminate() NOEXCEPT {} + +size_t YoloRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +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; +} + +size_t YoloRT::getSerializationSize() const NOEXCEPT { + return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + + YOLORT_CLASSNAME_W * classes * sizeof(char); +} + +bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +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; + std::cout<setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +YoloRTPluginCreator::YoloRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); + 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(); +} + +IPluginV2 *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; +} + +IPluginV2 *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + //todo assert + int classes = *(static_cast(fields[0].data)); + int num = *(static_cast(fields[1].data)); + Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); + int numMasks = *(static_cast(fields[3].data)); + float scaleXY = *(static_cast(fields[4].data)); + float nmsThresh = *(static_cast(fields[5].data)); + int nmsKind = *(static_cast(fields[6].data)); + int newCoords = *(static_cast(fields[7].data)); + YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *YoloRTPluginCreator::getPluginName() const NOEXCEPT { + return "YoloRT_tkDNN"; +} + +const char *YoloRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *YoloRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + -- 2.52.0 From 504dee5016bcedc104913a6214cba05fff18b34a Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 6 Sep 2021 15:35:57 +0530 Subject: [PATCH 11/58] test_yolo4 netRT->destroy() --- tests/darknet/yolo4.cpp | 1 + tests/darknet/yolo4tiny.cpp | 5 ----- 2 files changed, 1 insertion(+), 5 deletions(-) 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/yolo4tiny.cpp b/tests/darknet/yolo4tiny.cpp index 9a65f30..225433c 100644 --- a/tests/darknet/yolo4tiny.cpp +++ b/tests/darknet/yolo4tiny.cpp @@ -27,14 +27,9 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); std::cout<releaseLayers(); - std::cout<<"DELETING NET"<destroy(); delete netRT; - - std::cout<<"RETRUNING RET"< Date: Tue, 7 Sep 2021 07:20:46 +0530 Subject: [PATCH 12/58] tkdnn(trt8) runs now minus the detections ,[executionContext.cpp::enqueueInternal::312] Error Code 3: Internal Error (Parameter check failed at: runtime/api/executionContext.cpp::enqueueInternal::312, condition: mDeviceMemorySize == 0 || mExecutionResources->getDeviceMemory() != nullptr - is the error that causes it --- src/Yolo.cpp | 1 - src/Yolo3Detection.cpp | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Yolo.cpp b/src/Yolo.cpp index 35abb19..e6fb8ab 100644 --- a/src/Yolo.cpp +++ b/src/Yolo.cpp @@ -137,7 +137,6 @@ int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int net if(predictions == nullptr) predictions = new dnnType[output_dim.tot()]; - checkCuda(cudaDeviceSynchronize()); checkCuda( cudaMemcpy(predictions, dstData, output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost)); int lw = output_dim.w; diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 8d3d244..48e9d5d 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -45,7 +45,8 @@ namespace tk { namespace dnn { yolo[i]->bias_h = new dnnType[num*nMasks*2]; memcpy(yolo[i]->mask_h, maskTempF, sizeof(dnnType)*nMasks); memcpy(yolo[i]->bias_h, biasTempF, sizeof(dnnType)*num*nMasks*2); - yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, channels, height, width); + 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; -- 2.52.0 From 03473743c4348490d86941efe8410ea6b5478d43 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 7 Sep 2021 22:00:28 +0530 Subject: [PATCH 13/58] tkDNN works with trt8!!,need to test int8 and mobilenet,dla_cnet (fps seems to be a bit low 350 on trt8 compared to 396 on trt7) --- CMakeLists.txt | 4 ++-- demo/demo/demo.cpp | 21 ++++++++++++------- include/tkDNN/CenternetDetection.h | 2 +- include/tkDNN/MobilenetDetection.h | 2 +- src/CenternetDetection.cpp | 2 +- src/MobilenetDetection.cpp | 2 +- src/NetworkRT.cpp | 2 +- src/Yolo3Detection.cpp | 2 +- tests/darknet/csresnext50-panet-spp.cpp | 1 + .../csresnext50-panet-spp_berkeley.cpp | 1 + tests/darknet/yolo2_voc.cpp | 1 + tests/darknet/yolo2tiny.cpp | 1 + tests/darknet/yolo3.cpp | 1 + tests/darknet/yolo3_512.cpp | 1 + tests/darknet/yolo3_berkeley.cpp | 1 + tests/darknet/yolo3_coco4.cpp | 1 + tests/darknet/yolo3_flir.cpp | 1 + tests/darknet/yolo3tiny.cpp | 1 + tests/darknet/yolo3tiny_512.cpp | 1 + tests/darknet/yolo4-csp.cpp | 1 + tests/darknet/yolo4_320.cpp | 1 + tests/darknet/yolo4_320_coco2.cpp | 1 + tests/darknet/yolo4_512.cpp | 1 + tests/darknet/yolo4_608.cpp | 1 + tests/darknet/yolo4_berkeley.cpp | 1 + tests/darknet/yolo4_berkeley_f1.cpp | 1 + tests/darknet/yolo4_mmr.cpp | 1 + tests/darknet/yolo4tiny_512.cpp | 1 + tests/darknet/yolo4x.cpp | 1 + .../bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp | 1 + 30 files changed, 43 insertions(+), 16 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f3471e2..9191adc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15) project (tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") endif() if(WIN32) set(CMAKE_CXX_STANDARD 11) @@ -31,7 +31,7 @@ endif() find_package(CUDA 9.0 REQUIRED) SET(CUDA_SEPARABLE_COMPILATION ON) #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) +set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) find_package(CUDNN REQUIRED) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 6e1c2b4..d597da9 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -45,14 +45,14 @@ int main(int argc, char *argv[]) { if(argc > 2) - cfgPath = argv[2]; + cfgPath = argv[3]; if(argc > 3) - namePath = argv[3]; + namePath = argv[4]; if(argc > 4) - input = argv[4]; + input = argv[5]; char ntype = 'y'; if(argc > 5) - ntype = argv[5][0]; + ntype = argv[2][0]; int n_classes = 80; if(argc > 6) n_classes = atoi(argv[6]); @@ -72,9 +72,14 @@ int main(int argc, char *argv[]) { if(!show) SAVE_RESULT = true; + if(ntype == 'c' || ntype == 'm'){ + cfgPath = nullptr; + namePath = nullptr; + + } tk::dnn::Yolo3Detection yolo; - //tk::dnn::CenternetDetection cnet; - //tk::dnn::MobilenetDetection mbnet; + tk::dnn::CenternetDetection cnet; + tk::dnn::MobilenetDetection mbnet; tk::dnn::DetectionNN *detNN; @@ -84,10 +89,10 @@ int main(int argc, char *argv[]) { detNN = &yolo; break; case 'c': - //detNN = &cnet; + detNN = &cnet; break; case 'm': - //detNN = &mbnet; + detNN = &mbnet; n_classes++; break; default: 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/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/src/CenternetDetection.cpp b/src/CenternetDetection.cpp index a06bc11..133c682 100644 --- a/src/CenternetDetection.cpp +++ b/src/CenternetDetection.cpp @@ -3,7 +3,7 @@ namespace tk { namespace dnn { -bool CenternetDetection::init(const std::string& tensor_path, const int n_classes, const int n_batches, const float conf_thresh){ +bool CenternetDetection::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() ); classes = n_classes; 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 7f00cd6..4b3d532 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -657,8 +657,8 @@ bool NetworkRT::deserialize(const char *filename) { void NetworkRT::destroy() { contextRT->destroy(); - configRT->destroy(); engineRT->destroy(); + configRT->destroy(); builderRT->destroy(); } diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 48e9d5d..bda206a 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -29,7 +29,7 @@ namespace tk { namespace dnn { for(int i=0; i maskTemp,anchorsTemp; std::vector classNamesTemp; - int classes,nms_kind,coords,numTemp; + int nms_kind,coords,numTemp; float nmsthresh; loadYoloInfo(cfg_path,yolosLine[i],maskTemp,anchorsTemp,numTemp,classes,nmsthresh,nms_kind,coords); classNamesTemp = darknetReadNames(name_path); 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_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_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/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; } -- 2.52.0 From 18cc6abbb65f8ce17ac062f66447422003d0576b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 7 Sep 2021 23:57:52 +0530 Subject: [PATCH 14/58] DeformableConvRT.h fixes ,cmake cuda arch auto detection --- .gitignore | 3 +- CMakeLists.txt | 68 +++++++++++++++++++--- cmake/getCudaArch.cu | 20 +++++++ include/tkDNN/pluginsRT/DeformableConvRT.h | 2 +- 4 files changed, 82 insertions(+), 11 deletions(-) create mode 100644 cmake/getCudaArch.cu diff --git a/.gitignore b/.gitignore index c1d362c..683834c 100644 --- a/.gitignore +++ b/.gitignore @@ -19,4 +19,5 @@ 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 diff --git a/CMakeLists.txt b/CMakeLists.txt index 9191adc..c10f6ac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,15 +1,67 @@ cmake_minimum_required(VERSION 3.15) - -project (tkDNN) +project(tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) -if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") +set(CMAKE_CXX_STANDARD 14) + +find_package(CUDA 9.0 REQUIRED) +if (CUDA_FOUND) + #Get CUDA compute capability + set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required + set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) + execute_process(COMMAND nvcc -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}") + add_definitions(-DGPU) #You may not require this + + 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") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) + endif() + + if(CMAKE_BUILD_TYPE MATCHES Debug) + set(CMAKE_CXX_FLAGS "/Od /FS /EHsc") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61 -G -g) + endif() set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) endif(WIN32) + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/tkDNN) # project specific flags @@ -28,10 +80,8 @@ 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 -arch=sm_61) find_package(CUDNN REQUIRED) 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/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index adc5554..1cbf55d 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -110,6 +110,6 @@ namespace nvinfer1 { static std::vector mPluginAttributes; std::string mPluginNamespace; }; - + REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); }; #endif -- 2.52.0 From 54e7af11edfbcdc8751e9818841cee93f4e0c9ae Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 18 Oct 2021 18:07:57 +0530 Subject: [PATCH 15/58] tensorrt7 support for ipluginv2 --- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 4 ++ .../tkDNN/pluginsRT/ActivationLogisticRT.h | 5 ++ include/tkDNN/pluginsRT/ActivationMishRT.h | 5 +- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 5 +- include/tkDNN/pluginsRT/DeformableConvRT.h | 5 +- include/tkDNN/pluginsRT/FlattenConcatRT.h | 4 ++ .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 4 ++ include/tkDNN/pluginsRT/RegionRT.h | 4 ++ include/tkDNN/pluginsRT/ReorgRT.h | 4 ++ include/tkDNN/pluginsRT/ReshapeRT.h | 4 ++ include/tkDNN/pluginsRT/ResizeLayerRT.h | 5 ++ include/tkDNN/pluginsRT/RouteRT.h | 4 ++ include/tkDNN/pluginsRT/ShortcutRT.h | 4 ++ include/tkDNN/pluginsRT/UpsampleRT.h | 4 ++ include/tkDNN/pluginsRT/YoloRT.h | 5 ++ src/pluginsRT/ActivationLeakyRT.cpp | 15 +++++- src/pluginsRT/ActivationLogisticRT.cpp | 10 +++- src/pluginsRT/ActivationMishRT.cpp | 12 +++++ src/pluginsRT/ActivationReLUCeilingRT.cpp | 11 +++- src/pluginsRT/DeformableConvRT.cpp | 50 ++++++++++++------- src/pluginsRT/FlattenConcatRT.cpp | 20 +++++++- src/pluginsRT/MaxPoolingSizeRT.cpp | 21 ++++---- src/pluginsRT/RegionRT.cpp | 32 ++++++++++-- src/pluginsRT/ReorgRT.cpp | 13 ++++- src/pluginsRT/ReshapeRT.cpp | 14 +++++- src/pluginsRT/ResizeLayerRT.cpp | 15 ++++-- src/pluginsRT/RouteRT.cpp | 21 ++++++-- src/pluginsRT/ShortcutRT.cpp | 19 +++++-- src/pluginsRT/UpsampleRT.cpp | 15 +++++- src/pluginsRT/YoloRT.cpp | 43 ++++++++++++---- 30 files changed, 313 insertions(+), 64 deletions(-) diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index ae395ef..1d98a59 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -27,8 +27,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; +#if NV_TENSORRT_MAJOR > 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 size_t getSerializationSize() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index 9646efc..d972752 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -28,8 +28,13 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index 3c9f15a..5b966cd 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -26,8 +26,11 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index b5c186c..1830945 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -25,8 +25,11 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 1cbf55d..e0541ef 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -33,9 +33,12 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 7d655d3..b1e5327 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -25,7 +25,11 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 14f714e..723bed6 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -28,8 +28,12 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index cdcb515..400f2f0 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -30,8 +30,12 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index a780615..ced6b9c 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -27,8 +27,12 @@ namespace nvinfer1 { 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; diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index 8d3fdb5..a0cc718 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -31,7 +31,11 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index 7316048..a446698 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -29,8 +29,13 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 2b9bc67..499b9da 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -29,7 +29,11 @@ namespace nvinfer1 { 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 ; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 7069180..29afc85 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -32,8 +32,12 @@ namespace nvinfer1 { 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; diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 030fe5a..09f3547 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -30,8 +30,12 @@ namespace nvinfer1 { 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; diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 0d895e0..9479f9f 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -34,8 +34,13 @@ namespace nvinfer1 { 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; diff --git a/src/pluginsRT/ActivationLeakyRT.cpp b/src/pluginsRT/ActivationLeakyRT.cpp index 77063f6..2a9bf33 100644 --- a/src/pluginsRT/ActivationLeakyRT.cpp +++ b/src/pluginsRT/ActivationLeakyRT.cpp @@ -42,6 +42,7 @@ 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( @@ -51,6 +52,17 @@ int ActivationLeakyRT::enqueue(int batchSize, const void *const *inputs, void *c 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); @@ -94,8 +106,7 @@ IPluginV2* ActivationLeakyRT::clone() const NOEXCEPT { } ActivationLeakyRTPluginCreator::ActivationLeakyRTPluginCreator() { - mPluginAttributes.emplace_back( - PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ActivationLogisticRT.cpp b/src/pluginsRT/ActivationLogisticRT.cpp index 9966708..a3c4ae7 100644 --- a/src/pluginsRT/ActivationLogisticRT.cpp +++ b/src/pluginsRT/ActivationLogisticRT.cpp @@ -38,13 +38,21 @@ 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); diff --git a/src/pluginsRT/ActivationMishRT.cpp b/src/pluginsRT/ActivationMishRT.cpp index 7797df9..d42b90a 100644 --- a/src/pluginsRT/ActivationMishRT.cpp +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -38,12 +38,22 @@ 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); } @@ -80,6 +90,8 @@ IPluginV2 *ActivationMishRT::clone() const NOEXCEPT { return p; } + + ActivationMishRTPluginCreator::ActivationMishRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); diff --git a/src/pluginsRT/ActivationReLUCeilingRT.cpp b/src/pluginsRT/ActivationReLUCeilingRT.cpp index 80b5a74..c97d4ec 100644 --- a/src/pluginsRT/ActivationReLUCeilingRT.cpp +++ b/src/pluginsRT/ActivationReLUCeilingRT.cpp @@ -40,11 +40,20 @@ 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); @@ -86,7 +95,7 @@ void ActivationReLUCeiling::setPluginNamespace(const char *pluginNamespace) NOEX } ActivationReLUCeilingPluginCreator::ActivationReLUCeilingPluginCreator() { - mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 417af8e..62f7555 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -137,6 +137,7 @@ 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]); @@ -165,6 +166,36 @@ int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *co } 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 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + @@ -251,25 +282,8 @@ IPluginV2 *DeformableConvRT::clone() const NOEXCEPT { return p; } - DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 51cebc5..6687b58 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -54,6 +54,7 @@ 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]); @@ -69,6 +70,24 @@ int FlattenConcatRT::enqueue(int batchSize, const void *const *inputs, void *con } return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t FlattenConcatRT::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*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + checkERROR( cublasSetStream(handle, stream) ); + for(int i=0; i 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]); @@ -61,6 +62,16 @@ int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void * 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); @@ -110,16 +121,8 @@ IPluginV2 *MaxPoolFixedSizeRT::clone() const NOEXCEPT { return p; } - MaxPoolFixedSizeRTPluginCreator::MaxPoolFixedSizeRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index de1dd3b..552db3e 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -43,6 +43,7 @@ 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]); @@ -68,6 +69,32 @@ int RegionRT::enqueue(int batchSize, const void *const *inputs, void *const *out 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); @@ -112,11 +139,8 @@ IPluginV2 *RegionRT::clone() const NOEXCEPT { return p; } - RegionRTPluginCreator::RegionRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index d3dd12a..c2b0083 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -43,12 +43,22 @@ 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); @@ -93,9 +103,8 @@ IPluginV2 *ReorgRT::clone() const NOEXCEPT { return p; } - ReorgRTPluginCreator::ReorgRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index 5e23ab3..127e244 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -43,6 +43,7 @@ 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]); @@ -51,6 +52,16 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou 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]); + + 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); @@ -96,9 +107,8 @@ IPluginV2 *ReshapeRT::clone() const NOEXCEPT { return p; } - ReshapeRTPluginCreator::ReshapeRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp index 12a3ff9..dd8c912 100644 --- a/src/pluginsRT/ResizeLayerRT.cpp +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -47,6 +47,7 @@ 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]), @@ -54,6 +55,15 @@ int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const 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); @@ -101,11 +111,8 @@ IPluginV2 *ResizeLayerRT::clone() const NOEXCEPT { return p; } - ResizeLayerRTPluginCreator::ResizeLayerRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/RouteRT.cpp b/src/pluginsRT/RouteRT.cpp index 87233a5..3218622 100644 --- a/src/pluginsRT/RouteRT.cpp +++ b/src/pluginsRT/RouteRT.cpp @@ -60,6 +60,7 @@ size_t RouteRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 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]); @@ -75,6 +76,22 @@ int RouteRT::enqueue(int batchSize, const void *const *inputs, void *const *outp } 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); @@ -124,10 +141,8 @@ IPluginV2 *RouteRT::clone() const NOEXCEPT { return p; } - RouteRTPluginCreator::RouteRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index eb35bd6..3cedffa 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -50,6 +50,7 @@ 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]); @@ -61,6 +62,20 @@ int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *o 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); @@ -108,10 +123,8 @@ IPluginV2 *ShortcutRT::clone() const NOEXCEPT { return p; } - ShortcutRTPluginCreator::ShortcutRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index 044405b..d08a3ca 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -44,6 +44,7 @@ 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 { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -53,6 +54,17 @@ int UpsampleRT::enqueue(int batchSize, const void *const *inputs, void *const *o 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); @@ -97,9 +109,8 @@ IPluginV2 *UpsampleRT::clone() const NOEXCEPT { return p; } - UpsampleRTPluginCreator::UpsampleRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 7f615b4..c191afd 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -85,6 +85,7 @@ 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]); @@ -115,6 +116,38 @@ int YoloRT::enqueue(int batchSize, const void *const *inputs, void *const *outpu //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) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + @@ -182,16 +215,8 @@ IPluginV2 *YoloRT::clone() const NOEXCEPT { return p; } - YoloRTPluginCreator::YoloRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } -- 2.52.0 From 8c36dd04316af051438090dd78f517c23e071973 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 27 Oct 2021 18:00:33 +0530 Subject: [PATCH 16/58] mobilenet works with trt7(IPluginV2IOExt) ,need to test it with trt8 --- CMakeLists.txt | 12 ++-- include/tkDNN/Layer.h | 2 + include/tkDNN/pluginsRT/FlattenConcatRT.h | 29 ++++++---- src/Flatten.cpp | 5 ++ src/NetworkRT.cpp | 6 +- src/pluginsRT/FlattenConcatRT.cpp | 69 ++++++++++++++++------- src/pluginsRT/ReshapeRT.cpp | 5 +- 7 files changed, 88 insertions(+), 40 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index c10f6ac..bfdb426 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -51,13 +51,13 @@ endif() if(WIN32) if(CMAKE_BUILD_TYPE MATCHES Release) - set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") - set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) + 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") - set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61 -G -g) + 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) @@ -92,7 +92,7 @@ include_directories(${CUDNN_INCLUDE_DIR}) 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_LIBRAY} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) +target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) @@ -121,7 +121,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} ${CUDA_CUBLAS_LIBRAY}) +target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRARIES}) #static #add_library(tkDNN_static STATIC ${tkdnn_SRC}) diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 0c1c5ca..d08e517 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -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; }; /** diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index b1e5327..aa8f078 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -3,10 +3,10 @@ #include #include namespace nvinfer1 { - class FlattenConcatRT : public IPluginV2 { + class FlattenConcatRT : public IPluginV2IOExt { public: - FlattenConcatRT() ; + FlattenConcatRT(int c,int h,int w,int rows,int cols) ; FlattenConcatRT(const void *data, size_t length) ; @@ -16,9 +16,6 @@ namespace nvinfer1 { 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 ; @@ -37,8 +34,6 @@ namespace nvinfer1 { void destroy() NOEXCEPT override ; - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override ; const char *getPluginVersion() const NOEXCEPT override; @@ -47,7 +42,21 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2IOExt *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) 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; + + bool supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; int c, h, w; int rows, cols; @@ -65,9 +74,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2IOExt *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2IOExt *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/src/Flatten.cpp b/src/Flatten.cpp index 8906c88..0eb690c 100644 --- a/src/Flatten.cpp +++ b/src/Flatten.cpp @@ -15,6 +15,11 @@ Flatten::Flatten(Network *net) : Layer(net) { output_dim.w = 1; output_dim.l = 1; + this->h = 1; + this->w = 1; + this->rows = input_dim.w; + this->cols = input_dim.h * input_dim.c; + this->c = input_dim.w * input_dim.h * input_dim.c; } Flatten::~Flatten() { diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 4b3d532..0537e6a 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -18,9 +18,9 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { -#ifdef DEBUG +//#ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; -#endif +//#endif } } loggerRT; @@ -473,7 +473,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { - IPluginV2 *plugin = new FlattenConcatRT(); + IPluginV2IOExt *plugin = new FlattenConcatRT(l->c,l->h,l->w,l->rows,l->cols); IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 6687b58..6c54e47 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -4,12 +4,17 @@ using namespace nvinfer1; std::vector FlattenConcatRTPluginCreator::mPluginAttributes; PluginFieldCollection FlattenConcatRTPluginCreator::mFC{}; -FlattenConcatRT::FlattenConcatRT() { +FlattenConcatRT::FlattenConcatRT(int c, int h, int w, int rows, int cols) { stat = cublasCreate(&handle); if (stat != CUBLAS_STATUS_SUCCESS) { printf ("CUBLAS initialization failed\n"); return; } + this->c = c; + this->h = h; + this->w = w; + this->rows = rows; + this->cols = cols; } FlattenConcatRT::FlattenConcatRT(const void *data, size_t length) { @@ -32,16 +37,6 @@ Dims FlattenConcatRT::getOutputDimensions(int index, const Dims *inputs, int nbI return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; } -void FlattenConcatRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - 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; -} - int FlattenConcatRT::initialize() NOEXCEPT { return 0; } @@ -107,9 +102,7 @@ void FlattenConcatRT::destroy() NOEXCEPT { delete this; } -bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; -} + const char *FlattenConcatRT::getPluginType() const NOEXCEPT { return "FlattenConcatRT_tkDNN"; @@ -127,12 +120,44 @@ void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *FlattenConcatRT::clone() const NOEXCEPT { - auto *p = new FlattenConcatRT(); +IPluginV2IOExt *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::configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) NOEXCEPT +{ +} + +void FlattenConcatRT::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT +{ +} + +bool FlattenConcatRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT +{ + return false; +} + +bool FlattenConcatRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT +{ + return false; +} + +bool FlattenConcatRT::supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT +{ + return true; +} + +void FlattenConcatRT::detachFromContext() NOEXCEPT +{ +} + FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); @@ -147,15 +172,21 @@ const char *FlattenConcatRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, +IPluginV2IOExt *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; } -IPluginV2 *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { - auto *pluginObj = new FlattenConcatRT(); +IPluginV2IOExt *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; } diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index 127e244..f364ab0 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -54,10 +54,11 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou } #elif NV_TENSORRT_MAJOR == 7 int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + std::cout << new_dim.c << ":" << new_dim.h << std::endl; 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)); + std::cout << "C : " << c << "H : " << h << "w :" << w << std::endl; + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*new_dim.c*new_dim.h*new_dim.w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); return 0; } #endif -- 2.52.0 From c5e66c6bf637fe6eb8199fb02c49c8c8e750b242 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Thu, 28 Oct 2021 23:35:37 +0530 Subject: [PATCH 17/58] TRT8 works with almost every nerual network now!!!!(including demo3d) --- demo/demo/demo.cpp | 23 +- demo/demo/map.cpp | 21 +- include/tkDNN/Layer.h | 5 + include/tkDNN/pluginsRT/DeformableConvRT.h | 51 ++- include/tkDNN/pluginsRT/FlattenConcatRT.h | 22 +- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 28 +- include/tkDNN/pluginsRT/RegionRT.h | 31 +- include/tkDNN/pluginsRT/ReorgRT.h | 29 +- include/tkDNN/pluginsRT/ReshapeRT.h | 29 +- include/tkDNN/pluginsRT/ResizeLayerRT.h | 36 +- include/tkDNN/pluginsRT/ShortcutRT.h | 27 +- include/tkDNN/pluginsRT/UpsampleRT.h | 36 +- include/tkDNN/pluginsRT/YoloRT.h | 35 +- src/Flatten.cpp | 4 +- src/NetworkRT.cpp | 416 ++++++------------ src/Region.cpp | 1 - src/Reshape.cpp | 5 +- src/Shortcut.cpp | 3 + src/Upsample.cpp | 3 + src/pluginsRT/DeformableConvRT.cpp | 234 ++++++---- src/pluginsRT/FlattenConcatRT.cpp | 50 ++- src/pluginsRT/MaxPoolingSizeRT.cpp | 42 +- src/pluginsRT/RegionRT.cpp | 79 +++- src/pluginsRT/ReorgRT.cpp | 74 +++- src/pluginsRT/ReshapeRT.cpp | 88 +++- src/pluginsRT/ResizeLayerRT.cpp | 71 ++- src/pluginsRT/ShortcutRT.cpp | 96 ++-- src/pluginsRT/UpsampleRT.cpp | 73 ++- src/pluginsRT/YoloRT.cpp | 117 +++-- tests/centernet/dla34_cnet/dla34_cnet.cpp | 1 + tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp | 1 + .../resnet101_cnet/resnet101_cnet.cpp | 1 + .../mobilenetv2ssd/mobilenetv2ssd.cpp | 2 +- .../mobilenetv2ssd512/mobilenetv2ssd512.cpp | 2 +- tests/shelfnet/shelfnet.cpp | 2 +- tests/shelfnet/shelfnet_berkeley.cpp | 2 +- tests/shelfnet/shelfnet_mapillary.cpp | 2 +- 37 files changed, 1042 insertions(+), 700 deletions(-) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index d597da9..fbfbb6f 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -43,19 +43,18 @@ int main(int argc, char *argv[]) { std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; #endif - - if(argc > 2) - cfgPath = argv[3]; - if(argc > 3) - namePath = argv[4]; - if(argc > 4) - input = argv[5]; char ntype = 'y'; - if(argc > 5) + if(argc > 2) ntype = argv[2][0]; int n_classes = 80; + if(argc > 3) + n_classes = atoi(argv[3]); + if(argc > 4) + cfgPath = argv[4]; + if(argc > 5) + namePath = argv[5]; if(argc > 6) - n_classes = atoi(argv[6]); + input = argv[6]; int n_batch = 1; if(argc > 7) n_batch = atoi(argv[7]); @@ -63,7 +62,7 @@ int main(int argc, char *argv[]) { if(argc > 8) show = atoi(argv[8]); float conf_thresh=0.3; - if(argc > 9) + if(argc >= 9) conf_thresh = atof(argv[9]); if(n_batch < 1 || n_batch > 64) @@ -73,8 +72,8 @@ int main(int argc, char *argv[]) { SAVE_RESULT = true; if(ntype == 'c' || ntype == 'm'){ - cfgPath = nullptr; - namePath = nullptr; + cfgPath = ""; + namePath = ""; } tk::dnn::Yolo3Detection yolo; diff --git a/demo/demo/map.cpp b/demo/demo/map.cpp index 8486202..70bab07 100644 --- a/demo/demo/map.cpp +++ b/demo/demo/map.cpp @@ -32,7 +32,7 @@ int main(int argc, char *argv[]) { char ntype = 'y'; const char *config_filename = "../demo/config.yaml"; - const char * net = "yolo3.rt"; + const char * net = "yolo4tiny_fp32.rt"; const char * labels_path = "../demo/COCO_val2017/all_labels.txt"; int n_batches = 1; float confidence_thresh = 0.3; @@ -45,7 +45,8 @@ int main(int argc, char *argv[]) bool verbose; int classes, map_points, map_levels; float map_step, IoU_thresh, conf_thresh; - + std::string cfg_path = "../tests/darknet/cfg/yolo4tiny.cfg"; + std::string name_path = "../tests/darknet/names/coco.names"; double vm_total = 0, rss_total = 0; double vm, rss; @@ -53,15 +54,19 @@ int main(int argc, char *argv[]) if(argc > 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/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index d08e517..e09e5fa 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -438,6 +438,7 @@ public: virtual layerType_t getLayerType() { return LAYER_RESHAPE; }; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int n,c,h,w; }; @@ -584,6 +585,8 @@ public: virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int c,h,w; + public: Layer *backLayer; bool mul = false; @@ -604,6 +607,7 @@ public: int stride; bool reverse; + int c,h,w; }; struct box { @@ -687,6 +691,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/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index e0541ef..9170e15 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -8,14 +8,15 @@ #include namespace nvinfer1 { - class DeformableConvRT : public IPluginV2 { + class DeformableConvRT : public IPluginV2Ext { 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); + 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(); @@ -25,9 +26,6 @@ namespace nvinfer1 { 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 ; @@ -56,11 +54,26 @@ namespace nvinfer1 { const char *getPluginVersion() const NOEXCEPT override ; - IPluginV2 *clone() 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; + cublasHandle_t handle{nullptr}; int i_n, i_c, i_h, i_w; int o_n, o_c, o_h, o_w; int size; @@ -73,12 +86,18 @@ namespace nvinfer1 { int width_ones; int dim_ones; - dnnType *data_d; - dnnType *bias2_d; - dnnType *ones_d1; - dnnType *offset; - dnnType *mask; - dnnType *ones_d2; + 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; @@ -99,9 +118,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index aa8f078..02ff596 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -3,7 +3,7 @@ #include #include namespace nvinfer1 { - class FlattenConcatRT : public IPluginV2IOExt { + class FlattenConcatRT : public IPluginV2Ext { public: FlattenConcatRT(int c,int h,int w,int rows,int cols) ; @@ -24,7 +24,7 @@ namespace nvinfer1 { #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 +#elif NV_TENSORRT_MAJOR <= 7 int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; #endif @@ -42,26 +42,28 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2IOExt *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; - void configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) 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; - bool supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) 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; - cublasStatus_t stat; - cublasHandle_t handle; + cublasHandle_t handle{nullptr}; private: std::string mPluginNamespace; }; @@ -74,9 +76,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2IOExt *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2IOExt *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 723bed6..95e15f4 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -6,7 +6,7 @@ namespace nvinfer1 { - class MaxPoolFixedSizeRT : public IPluginV2 { + class MaxPoolFixedSizeRT : public IPluginV2Ext { public: MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) ; @@ -19,9 +19,6 @@ namespace nvinfer1 { 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 ; @@ -31,7 +28,7 @@ namespace nvinfer1 { #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 +#elif NV_TENSORRT_MAJOR <= 7 int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; #endif @@ -52,7 +49,22 @@ namespace nvinfer1 { const char *getPluginVersion() const NOEXCEPT override ; - IPluginV2 *clone() 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; @@ -72,9 +84,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index 400f2f0..7f7157c 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -7,10 +7,10 @@ #include namespace nvinfer1 { - class RegionRT : public IPluginV2 { + class RegionRT : public IPluginV2Ext { public: - RegionRT(int classes, int coords, int num); + RegionRT(int classes, int coords, int num,int c,int h,int w); ~RegionRT() ; @@ -20,9 +20,6 @@ namespace nvinfer1 { 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 ; @@ -32,7 +29,7 @@ namespace nvinfer1 { #if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override ; + 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 @@ -54,7 +51,22 @@ namespace nvinfer1 { bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - IPluginV2 *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; + + IPluginV2Ext *clone() const NOEXCEPT override ; int c, h, w; int classes, coords, num; @@ -76,9 +88,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; @@ -96,4 +108,3 @@ namespace nvinfer1 { }; #endif - diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index ced6b9c..be163a5 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -4,10 +4,10 @@ #include namespace nvinfer1 { - class ReorgRT : public IPluginV2 { + class ReorgRT : public IPluginV2Ext { public: - ReorgRT(int stride); + ReorgRT(int stride,int c,int h,int w); ~ReorgRT(); @@ -17,10 +17,6 @@ namespace nvinfer1 { 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; @@ -51,7 +47,22 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() 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 c, h, w, stride; private: @@ -66,9 +77,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index a0cc718..e56c79c 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -9,10 +9,10 @@ using namespace tk::dnn; namespace nvinfer1 { - class ReshapeRT : public IPluginV2 { + class ReshapeRT : public IPluginV2Ext { public: - explicit ReshapeRT(dataDim_t newDim) ; + ReshapeRT(int n,int c,int h,int w) ; ReshapeRT(const void *data, size_t length) ; @@ -22,8 +22,6 @@ namespace nvinfer1 { 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 ; @@ -53,9 +51,24 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() 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; - dataDim_t new_dim; private: std::string mPluginNamespace; }; @@ -68,9 +81,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index a446698..750057e 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -6,10 +6,10 @@ namespace nvinfer1 { - class ResizeLayerRT : public IPluginV2 { + class ResizeLayerRT : public IPluginV2Ext { public: - ResizeLayerRT(int c, int h, int w) ; + ResizeLayerRT(int oc, int oh, int ow,int ic,int ih,int iw) ; ResizeLayerRT(const void *data, size_t length) ; @@ -19,10 +19,6 @@ namespace nvinfer1 { 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 ; @@ -32,12 +28,10 @@ namespace nvinfer1 { #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 +#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 ; @@ -54,7 +48,22 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() 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 i_c, i_h, i_w, o_c, o_h, o_w; @@ -70,9 +79,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; @@ -80,6 +89,9 @@ namespace nvinfer1 { const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + + private: static PluginFieldCollection mFC; static std::vector mPluginAttributes; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 29afc85..0c01b9d 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -10,10 +10,10 @@ namespace nvinfer1 { - class ShortcutRT : public IPluginV2 { + class ShortcutRT : public IPluginV2Ext { public: - ShortcutRT(tk::dnn::dataDim_t bdim, bool mul); + ShortcutRT(int bc,int bh,int bw,int c,int h,int w ,bool mul); ~ShortcutRT(); @@ -23,8 +23,19 @@ namespace nvinfer1 { 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; + 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; @@ -56,10 +67,10 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override; + IPluginV2Ext *clone() const NOEXCEPT override; int c, h, w; - int bc, bh, bw; + int bc, bh, bw,bl; bool mul; tk::dnn::dataDim_t bDim; private: @@ -75,9 +86,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 09f3547..4379ee7 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -8,10 +8,10 @@ namespace nvinfer1 { - class UpsampleRT : public IPluginV2 { + class UpsampleRT : public IPluginV2Ext { public: - explicit UpsampleRT(int stride); + UpsampleRT(int stride,int c,int h,int w); UpsampleRT(const void *data, size_t length); @@ -21,9 +21,6 @@ namespace nvinfer1 { 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; @@ -54,12 +51,27 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; - int c, h, w, stride; - private: - std::string mPluginNamespace; - }; + 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: @@ -69,9 +81,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 9479f9f..42ebcc7 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -10,10 +10,11 @@ #define YOLORT_CLASSNAME_W 256 namespace nvinfer1 { - class YoloRT : public IPluginV2 { + class YoloRT : public IPluginV2Ext { public: - YoloRT(int classes, int num, tk::dnn::Yolo *Yolo = nullptr, int n_masks = 3, float scale_xy = 1, + YoloRT(int classes, int num,int c,int h,int w,std::vector classNames, + std::vector masks_v,std::vector bias_v, 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); @@ -25,9 +26,6 @@ namespace nvinfer1 { 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; @@ -59,9 +57,24 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() 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; + - tk::dnn::Yolo *yolo; int c, h, w; int classes, num, n_masks; float scaleXY; @@ -71,8 +84,8 @@ namespace nvinfer1 { int NUM = 0; std::vector classesNames; - dnnType *mask; - dnnType *bias; + std::vector mask; + std::vector bias; int entry_index(int batch, int location, int entry) { int n = location / (w * h); @@ -93,9 +106,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/src/Flatten.cpp b/src/Flatten.cpp index 0eb690c..17e3a56 100644 --- a/src/Flatten.cpp +++ b/src/Flatten.cpp @@ -17,8 +17,8 @@ Flatten::Flatten(Network *net) : Layer(net) { this->h = 1; this->w = 1; - this->rows = input_dim.w; - this->cols = input_dim.h * input_dim.c; + this->rows = input_dim.c; + this->cols = input_dim.h * input_dim.w; this->c = input_dim.w * input_dim.h * input_dim.c; } diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 0537e6a..dc2e337 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -18,9 +18,9 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { -//#ifdef DEBUG +#ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; -//#endif +#endif } } loggerRT; @@ -472,18 +472,36 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { } ILayer* 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(); - IPluginV2IOExt *plugin = new FlattenConcatRT(l->c,l->h,l->w,l->rows,l->cols); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + 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) { // std::cout<<"convert Reshape\n"; - - IPluginV2 *plugin = new ReshapeRT(l->output_dim); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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; } @@ -503,8 +521,17 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { //std::cout<<"convert Reorg\n"; //std::cout<<"New plugin REORG\n"; - IPluginV2 *plugin = new ReorgRT(l->stride); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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; } @@ -513,8 +540,19 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Region *l) { //std::cout<<"convert Region\n"; //std::cout<<"New plugin REGION\n"; - IPluginV2 *plugin = new RegionRT(l->classes, l->coords, l->num); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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; } @@ -535,22 +573,52 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { else { // plugin version - IPluginV2 *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; - IPluginV2Layer *lRT = networkRT->addPluginV2(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"; - //std::cout<<"New plugin YOLO\n"; - IPluginV2 *plugin = new YoloRT(l->classes, l->num, l, l->n_masks, l->scaleXY, l->nms_thresh, l->nsm_kind, l->new_coords); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + std::vector mask_h(l->mask_h,l->mask_h+sizeof(dnnType)*l->n_masks); + std::vector bias_h(l->bias_h,l->bias_h+sizeof(dnnType)*2*l->n_masks*l->num); + 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("classNames",&l->classesNames[0],PluginFieldType::kUNKNOWN,l->classesNames.size())); + mPluginAttributes.emplace_back(PluginField("mask_v",&mask_h[0],PluginFieldType::kFLOAT32,mask_h.size())); + mPluginAttributes.emplace_back(PluginField("bias_v",&bias_h[0],PluginFieldType::kFLOAT32,bias_h.size())); + 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; } @@ -558,9 +626,17 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; - std::cout<<"New plugin UPSAMPLE\n"; - IPluginV2 *plugin = new UpsampleRT(l->stride); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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; } @@ -575,10 +651,53 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { inputs[1] = preconv->getOutput(0); //std::cout<<"New plugin DEFORMABLE\n"; - IPluginV2 *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); - IPluginV2Layer *lRT = networkRT->addPluginV2(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); @@ -658,254 +777,7 @@ bool NetworkRT::deserialize(const char *filename) { void NetworkRT::destroy() { contextRT->destroy(); engineRT->destroy(); - configRT->destroy(); builderRT->destroy(); } - - - -/* -IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialData, size_t serialLength) { - const char * buf = reinterpret_cast(serialData),*bufCheck = buf; - - std::string name(layerName); - //std::cout<(buf)); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; - } - 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/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/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 62f7555..1dc4d1a 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -1,14 +1,19 @@ #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, - tk::dnn::DeformConv2d *deformable) { + 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; @@ -25,11 +30,15 @@ DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw this->o_c = o_c; this->o_h = o_h; this->o_w = o_w; - this->defRT = deformable; - - 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; + 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))); @@ -37,17 +46,15 @@ DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw 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) { - 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) ); + 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)); } - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - FatalError("CUBLAS initialization failed\n"); + } @@ -79,42 +86,27 @@ DeformableConvRT::DeformableConvRT(const void *data, size_t length) { o_c = readBUF(buf); o_h = readBUF(buf); o_w = readBUF(buf); - dnnType *aus = new dnnType[chunk_dim*2]; + height_ones = readBUF(buf); + width_ones = readBUF(buf); + dim_ones = readBUF(buf); + offset_v.resize(chunk_dim*2); for(int i=0;i(buf); - checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); - - aus = new dnnType[chunk_dim]; + offset_v[i] = readBUF(buf); + mask_v.resize(chunk_dim); for(int i=0;i(buf); - checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); - - aus = new dnnType[i_c*o_c*kh*kw*1]; + mask_v[i] = readBUF(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++) - aus[i] = readBUF(buf); - checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); - free(aus); - - aus = new dnnType[o_c]; + data_d_v[i] = readBUF(buf); + bias2_d_v.resize(o_c); for(int i=0; i < o_c; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); - free(aus); - - aus = new dnnType[height_ones * width_ones]; + bias2_d_v[i] = readBUF(buf); + ones_d1_v.resize(height_ones*width_ones); for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); - free(aus); - - aus = new dnnType[dim_ones]; + ones_d1_v[i] = readBUF(buf); + ones_d2_v.resize(dim_ones); for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); - free(aus); - + ones_d2_v[i] = readBUF(buf); assert(buf == bufCheck + length); } @@ -124,11 +116,9 @@ int DeformableConvRT::getNbOutputs() const NOEXCEPT { } Dims DeformableConvRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { - return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; + return Dims3{o_c, o_h, o_w}; } -void DeformableConvRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} - int DeformableConvRT::initialize() NOEXCEPT { return 0; } @@ -166,7 +156,7 @@ int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *co } return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#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]); @@ -198,7 +188,7 @@ int32_t DeformableConvRT::enqueue(int32_t batchSize, const void *const *inputs, #endif size_t DeformableConvRT::getSerializationSize() const NOEXCEPT { - return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + + 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); } @@ -220,45 +210,27 @@ void DeformableConvRT::serialize(void *buffer) const NOEXCEPT { writeBUF(buf, o_c); writeBUF(buf, o_h); 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; 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 true; +} + DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("chunk_dim", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformable_group", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("offset_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("ones_d2_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("ones_d1_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("data_d_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("bias2_d_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("height_ones", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("width_ones", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("dim_ones", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -296,14 +328,14 @@ const char *DeformableConvRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *DeformableConvRTPluginCreator::deserializePlugin(const char *name, const void *serialData, +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; } -IPluginV2 *DeformableConvRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +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)); @@ -320,19 +352,27 @@ IPluginV2 *DeformableConvRTPluginCreator::createPlugin(const char *name, const P 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[14].data)); - auto *defRT = const_cast(static_cast(fields[15].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,defRT); + 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_tkDNN"; + return DEFORMABLECONVRT_PLUGIN_NAME; } const char *DeformableConvRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return DEFORMABLECONVRT_PLUGIN_VERSION; } const PluginFieldCollection *DeformableConvRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 6c54e47..c281579 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -4,12 +4,10 @@ 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) { - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) { - printf ("CUBLAS initialization failed\n"); - return; - } this->c = c; this->h = h; this->w = w; @@ -42,7 +40,7 @@ int FlattenConcatRT::initialize() NOEXCEPT { } void FlattenConcatRT::terminate() NOEXCEPT { - checkERROR(cublasDestroy(handle)); + } size_t FlattenConcatRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { @@ -105,11 +103,11 @@ void FlattenConcatRT::destroy() NOEXCEPT { const char *FlattenConcatRT::getPluginType() const NOEXCEPT { - return "FlattenConcatRT_tkDNN"; + return FLATTENCONCATRT_PLUGIN_NAME; } const char *FlattenConcatRT::getPluginVersion() const NOEXCEPT { - return "1"; + return FLATTENCONCATRT_PLUGIN_VERSION; } const char *FlattenConcatRT::getPluginNamespace() const NOEXCEPT { @@ -120,7 +118,7 @@ void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2IOExt *FlattenConcatRT::clone() const NOEXCEPT { +IPluginV2Ext *FlattenConcatRT::clone() const NOEXCEPT { auto* p = new FlattenConcatRT(c, h, w, rows, cols); p->setPluginNamespace(mPluginNamespace.c_str()); return p; @@ -131,12 +129,10 @@ DataType FlattenConcatRT::getOutputDataType(int index, const nvinfer1::DataType* return DataType::kFLOAT; } -void FlattenConcatRT::configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) NOEXCEPT -{ -} void FlattenConcatRT::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT { + handle = cublasContext; } bool FlattenConcatRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT @@ -149,17 +145,29 @@ bool FlattenConcatRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEP return false; } -bool FlattenConcatRT::supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT -{ - return true; -} - 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 true; +} + FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("rows", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("cols", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -172,14 +180,14 @@ const char *FlattenConcatRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2IOExt *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, +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; } -IPluginV2IOExt *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +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)); @@ -192,11 +200,11 @@ IPluginV2IOExt *FlattenConcatRTPluginCreator::createPlugin(const char *name, con } const char *FlattenConcatRTPluginCreator::getPluginName() const NOEXCEPT { - return "FlattenConcatRT_tkDNN"; + return FLATTENCONCATRT_PLUGIN_NAME; } const char *FlattenConcatRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return FLATTENCONCATRT_PLUGIN_VERSION; } const PluginFieldCollection *FlattenConcatRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp index 33316b7..5f36ae3 100644 --- a/src/pluginsRT/MaxPoolingSizeRT.cpp +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -40,8 +40,6 @@ Dims MaxPoolFixedSizeRT::getOutputDimensions(int index, const Dims *inputs, int return Dims3{this->c, this->h, this->w}; } -void MaxPoolFixedSizeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} - int MaxPoolFixedSizeRT::initialize() NOEXCEPT { return 0; } @@ -62,7 +60,7 @@ int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void * 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 +#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]); @@ -115,12 +113,43 @@ const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { return "1"; } -IPluginV2 *MaxPoolFixedSizeRT::clone() const NOEXCEPT { +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(); @@ -135,15 +164,14 @@ const char *MaxPoolFixedSizeRTPluginCreator::getPluginNamespace() const NOEXCEPT return mPluginNamespace.c_str(); } -IPluginV2 *MaxPoolFixedSizeRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - //todo assert int c = *(static_cast(fields[0].data)); int h = *(static_cast(fields[1].data)); int w = *(static_cast(fields[2].data)); diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index 552db3e..2d9899c 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -1,12 +1,19 @@ #include using namespace nvinfer1; + std::vector RegionRTPluginCreator::mPluginAttributes; PluginFieldCollection RegionRTPluginCreator::mFC{}; -RegionRT::RegionRT(int classes, int coords, int num) { +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() {} @@ -30,12 +37,6 @@ Dims RegionRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDim return inputs[0]; } -void RegionRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} int RegionRT::initialize() NOEXCEPT {return 0;} @@ -112,11 +113,11 @@ void RegionRT::serialize(void *buffer) const NOEXCEPT { } const char *RegionRT::getPluginType() const NOEXCEPT { - return "RegionRT_tkDNN"; + return REGIONRT_PLUGIN_NAME; } const char *RegionRT::getPluginVersion() const NOEXCEPT { - return "1"; + return REGIONRT_PLUGIN_VERSION; } void RegionRT::destroy() NOEXCEPT { delete this; } @@ -133,14 +134,48 @@ bool RegionRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT return true; } -IPluginV2 *RegionRT::clone() const NOEXCEPT { - auto *p = new RegionRT(classes,coords,num); +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(); + mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -153,32 +188,35 @@ const char *RegionRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *RegionRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); + 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)); - RegionRT *pluginObj = new RegionRT(classes,coords,num); + 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_tkDNN"; + return REGIONRT_PLUGIN_NAME; } const char *RegionRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return REGIONRT_PLUGIN_VERSION; } const PluginFieldCollection *RegionRTPluginCreator::getFieldNames() NOEXCEPT { @@ -195,4 +233,3 @@ const PluginFieldCollection *RegionRTPluginCreator::getFieldNames() NOEXCEPT { - diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index c2b0083..b1e7b1f 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -4,8 +4,14 @@ using namespace nvinfer1; std::vector ReorgRTPluginCreator::mPluginAttributes; PluginFieldCollection ReorgRTPluginCreator::mFC{}; -ReorgRT::ReorgRT(int stride) { +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() {} @@ -27,11 +33,6 @@ Dims ReorgRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; } -void ReorgRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} int ReorgRT::initialize() NOEXCEPT { return 0; @@ -50,7 +51,7 @@ int ReorgRT::enqueue(int batchSize, const void *const *inputs, void *const *outp batchSize, c, h, w, stride, stream); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#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]), @@ -78,11 +79,11 @@ bool ReorgRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT } const char *ReorgRT::getPluginType() const NOEXCEPT { - return "ReorgRT_tkDNN"; + return REORGRT_PLUGIN_NAME; } const char *ReorgRT::getPluginVersion() const NOEXCEPT { - return "1"; + return REORGRT_PLUGIN_VERSION; } void ReorgRT::destroy() NOEXCEPT { @@ -97,14 +98,45 @@ void ReorgRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ReorgRT::clone() const NOEXCEPT { - auto *p = new ReorgRT(stride); +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(); + mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -117,28 +149,34 @@ const char *ReorgRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ReorgRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - assert(fc->nbFields == 1); - assert(fields[0].type == PluginFieldType::kINT32); + assert(fc->nbFields == 4); + for(int i=0;i<4;i++){ + assert(fields[1].type == PluginFieldType::kINT32); + } int stride = *(static_cast(fields[0].data)); - auto *pluginObj = new ReorgRT(stride); + 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_tkDNN"; + return REORGRT_PLUGIN_NAME; } const char *ReorgRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return REORGRT_PLUGIN_VERSION; } const PluginFieldCollection *ReorgRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index f364ab0..dbe59c0 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -4,20 +4,22 @@ using namespace nvinfer1; std::vector ReshapeRTPluginCreator::mPluginAttributes; PluginFieldCollection ReshapeRTPluginCreator::mFC{}; -ReshapeRT::ReshapeRT(dataDim_t newDim) { - new_dim = newDim; - n = new_dim.n; - c = new_dim.c; - h = new_dim.h; - w = new_dim.w; +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; - new_dim.n = readBUF(buf); - new_dim.c = readBUF(buf); - new_dim.h = readBUF(buf); - new_dim.w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); assert(buf == bufCheck + length); } @@ -31,8 +33,6 @@ Dims ReshapeRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDi return Dims3{ c,h,w} ; } -void ReshapeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} - int ReshapeRT::initialize() NOEXCEPT { return 0; } @@ -48,11 +48,10 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou 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 +#elif NV_TENSORRT_MAJOR <= 7 int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { std::cout << new_dim.c << ":" << new_dim.h << std::endl; dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -83,11 +82,11 @@ bool ReshapeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEP } const char *ReshapeRT::getPluginType() const NOEXCEPT { - return "ReshapeRT_tkDNN"; + return RESHAPERT_PLUGIN_NAME; } const char *ReshapeRT::getPluginVersion() const NOEXCEPT { - return "1"; + return RESHAPERT_PLUGIN_VERSION; } void ReshapeRT::destroy() NOEXCEPT { @@ -102,14 +101,47 @@ void ReshapeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ReshapeRT::clone() const NOEXCEPT { - auto *p = new ReshapeRT(new_dim); +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(); + mPluginAttributes.emplace_back(PluginField("n", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -122,26 +154,34 @@ const char *ReshapeRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ReshapeRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - dataDim_t newDim = *(static_cast(fields[0].data)); - ReshapeRT *pluginObj = new ReshapeRT(newDim); + 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_tkDNN"; + return RESHAPERT_PLUGIN_NAME; } const char *ReshapeRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return RESHAPERT_PLUGIN_VERSION; } const PluginFieldCollection *ReshapeRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp index dd8c912..db98326 100644 --- a/src/pluginsRT/ResizeLayerRT.cpp +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -5,10 +5,13 @@ std::vector ResizeLayerRTPluginCreator::mPluginAttributes; PluginFieldCollection ResizeLayerRTPluginCreator::mFC{}; -ResizeLayerRT::ResizeLayerRT(int c, int h, int w) { - o_c = c; - o_h = h; - o_w = w; +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) { @@ -32,13 +35,6 @@ Dims ResizeLayerRT::getOutputDimensions(int index, const Dims *inputs, int nbInp return Dims3{o_c, o_h, o_w}; } -void ResizeLayerRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - i_c = inputDims[0].d[0]; - i_h = inputDims[0].d[1]; - i_w = inputDims[0].d[2]; -} - int ResizeLayerRT::initialize() NOEXCEPT { return 0; } @@ -55,7 +51,7 @@ int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#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]), @@ -105,12 +101,42 @@ void ResizeLayerRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ResizeLayerRT::clone() const NOEXCEPT { - auto *p = new ResizeLayerRT(o_c,o_h,o_w); +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(); @@ -125,22 +151,25 @@ const char *ResizeLayerRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ResizeLayerRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); + 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)); - auto *pluginObj = new ResizeLayerRT(oc,oh,ow); + 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; } diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index 3cedffa..ea18b0e 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -4,22 +4,26 @@ using namespace nvinfer1; std::vector ShortcutRTPluginCreator::mPluginAttributes; PluginFieldCollection ShortcutRTPluginCreator::mFC{}; -ShortcutRT::ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - bDim = bdim; - this->bc = bDim.c; - this->bh = bDim.h; - this->bw = bDim.w; +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; - bDim.c = readBUF(buf); - bDim.h = readBUF(buf); - bDim.w = readBUF(buf); - bDim.l = 1; + bc = readBUF(buf); + bh = readBUF(buf); + bw = readBUF(buf); mul = readBUF(buf); c = readBUF(buf); h = readBUF(buf); @@ -35,13 +39,6 @@ Dims ShortcutRT::getOutputDimensions(int index, const Dims *inputs, int nbInputD return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; } -void ShortcutRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} - int ShortcutRT::initialize() NOEXCEPT { return 0; } @@ -62,7 +59,7 @@ int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *o return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#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]); @@ -98,11 +95,11 @@ bool ShortcutRT::supportsFormat(DataType type, PluginFormat format) const NOEXCE } const char *ShortcutRT::getPluginType() const NOEXCEPT { - return "ShortcutRT_tkDNN"; + return SHORTCUTRT_PLUGIN_NAME; } const char *ShortcutRT::getPluginVersion() const NOEXCEPT { - return "1"; + return SHORTCUTRT_PLUGIN_VERSION; } void ShortcutRT::destroy() NOEXCEPT { @@ -117,14 +114,50 @@ void ShortcutRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ShortcutRT::clone() const NOEXCEPT { - auto *p = new ShortcutRT(bDim,mul); +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(); + mPluginAttributes.emplace_back(PluginField("bc", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bh", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mul", nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -137,28 +170,33 @@ const char *ShortcutRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ShortcutRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - //todo assert - tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); - bool mul = *(static_cast(fields[1].data)); - auto *pluginObj = new ShortcutRT(bdim,mul); + 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_tkDNN"; + return SHORTCUTRT_PLUGIN_NAME; } const char *ShortcutRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return SHORTCUTRT_PLUGIN_VERSION; } const PluginFieldCollection *ShortcutRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index d08a3ca..6859984 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -4,8 +4,14 @@ using namespace nvinfer1; std::vector UpsampleRTPluginCreator::mPluginAttributes; PluginFieldCollection UpsampleRTPluginCreator::mFC{}; -UpsampleRT::UpsampleRT(int stride) { +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) { @@ -27,12 +33,7 @@ Dims UpsampleRT::getOutputDimensions(int index, const Dims *inputs, int nbInputD return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); } -void UpsampleRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} + int UpsampleRT::initialize() NOEXCEPT { return 0; @@ -47,14 +48,14 @@ size_t UpsampleRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { #if NV_TENSORRT_MAJOR > 7 int UpsampleRT::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]); + 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 +#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]); @@ -84,11 +85,11 @@ bool UpsampleRT::supportsFormat(DataType type, PluginFormat format) const NOEXCE } const char *UpsampleRT::getPluginType() const NOEXCEPT { - return "Upsample_tkDNN"; + return UPSAMPLERT_PLUGIN_NAME; } const char *UpsampleRT::getPluginVersion() const NOEXCEPT { - return "1"; + return UPSAMPLERT_PLUGIN_VERSION; } void UpsampleRT::destroy() NOEXCEPT { @@ -103,14 +104,45 @@ void UpsampleRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *UpsampleRT::clone() const NOEXCEPT { - auto *p = new UpsampleRT(stride); +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(); + mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -123,26 +155,29 @@ const char *UpsampleRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *UpsampleRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; int stride = *(static_cast(fields[0].data)); - auto *pluginObj = new UpsampleRT(stride); + 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 "Upsample_tkDNN"; + return UPSAMPLERT_PLUGIN_NAME; } const char *UpsampleRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return UPSAMPLERT_PLUGIN_VERSION; } const PluginFieldCollection *UpsampleRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index c191afd..aa99415 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -1,12 +1,21 @@ #include + +#include using namespace nvinfer1; std::vector YoloRTPluginCreator::mPluginAttributes; PluginFieldCollection YoloRTPluginCreator::mFC{}; -YoloRT::YoloRT(int classes, int num, tk::dnn::Yolo *Yolo, int n_masks, float scale_xy, float nms_thresh, int nms_kind, +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,std::vector classNames, + std::vector masks_v,std::vector bias_v,int n_masks, float scale_xy, + float nms_thresh, int nms_kind, int new_coords) { - this->yolo = Yolo; + this->c = c; + this->h = h; + this->w = w; this->classes = classes; this->num = num; this->n_masks = n_masks; @@ -14,14 +23,10 @@ YoloRT::YoloRT(int classes, int num, tk::dnn::Yolo *Yolo, int n_masks, float sca this->nms_thresh = nms_thresh; this->nms_kind = nms_kind; this->new_coords = new_coords; + this->classesNames = std::move(classNames); + this->mask = std::move(masks_v); + this->bias = std::move(bias_v); - 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; - } } YoloRT::YoloRT(const void *data, size_t length) { @@ -38,16 +43,14 @@ YoloRT::YoloRT(const void *data, size_t length) { c = readBUF(buf); h = readBUF(buf); w = readBUF(buf); + mask.resize(n_masks); for(int i=0;i(buf)); - std::cout<(buf); } + bias.resize(n_masks*2*num); for(int i=0;i(buf)); - std::cout<(buf); } - mask = maskTemp.data(); - bias = biasTemp.data(); classesNames.resize(classes); for(int i=0;isetPluginNamespace(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(); + mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("classNames", nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("bias_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("n_masks", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scaleXy", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_thresh", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_kind", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("new_coords", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -229,34 +267,37 @@ const char *YoloRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *YoloRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +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; } -IPluginV2 *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - //todo assert int classes = *(static_cast(fields[0].data)); int num = *(static_cast(fields[1].data)); - Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); - int numMasks = *(static_cast(fields[3].data)); - float scaleXY = *(static_cast(fields[4].data)); - float nmsThresh = *(static_cast(fields[5].data)); - int nmsKind = *(static_cast(fields[6].data)); - int newCoords = *(static_cast(fields[7].data)); - YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + int c = *(static_cast(fields[2].data)); + int h = *(static_cast(fields[3].data)); + int w = *(static_cast(fields[4].data)); + std::vector classNames(static_cast(fields[5].data),static_cast(fields[5].data) + fields[5].length); + std::vector mask_v(static_cast(fields[6].data),static_cast(fields[6].data) + fields[6].length); + std::vector bias_v(static_cast(fields[7].data),static_cast(fields[7].data) + fields[7].length); + int n_masks = *(static_cast(fields[8].data)); + dnnType scaleXY = *(static_cast(fields[9].data)); + dnnType nmsThresh = *(static_cast(fields[10].data)); + int nms_kind = *(static_cast(fields[11].data)); + int new_coords = *(static_cast(fields[12].data)); + auto *pluginObj = new YoloRT(classes,num,c,h,w,classNames,mask_v,bias_v,n_masks,scaleXY,nmsThresh,nms_kind,new_coords); return pluginObj; } const char *YoloRTPluginCreator::getPluginName() const NOEXCEPT { - return "YoloRT_tkDNN"; + return YOLORT_PLUGIN_NAME; } const char *YoloRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return YOLORT_PLUGIN_VERSION; } const PluginFieldCollection *YoloRTPluginCreator::getFieldNames() NOEXCEPT { 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/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..bacb507 100644 --- a/tests/shelfnet/shelfnet_berkeley.cpp +++ b/tests/shelfnet/shelfnet_berkeley.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_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; } -- 2.52.0 From 7a89a4a5738e4d5b76d0d95cc2dfbcc45bd637ee Mon Sep 17 00:00:00 2001 From: perseusdg Date: Thu, 28 Oct 2021 23:43:12 +0530 Subject: [PATCH 18/58] ReshapeRT.cpp fix --- src/pluginsRT/ReshapeRT.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index dbe59c0..43cf8af 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -53,11 +53,10 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou } #elif NV_TENSORRT_MAJOR <= 7 int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { - std::cout << new_dim.c << ":" << new_dim.h << std::endl; 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*new_dim.c*new_dim.h*new_dim.w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); return 0; } #endif -- 2.52.0 From 802c01bd8f75fa67b51173f8668c8b518a09b421 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 30 Oct 2021 19:29:21 +0530 Subject: [PATCH 19/58] windows debug fix --- CMakeLists.txt | 2 +- demo/demo/demo.cpp | 2 +- src/pluginsRT/DeformableConvRT.cpp | 25 ------------------------- src/pluginsRT/FlattenConcatRT.cpp | 5 ----- src/pluginsRT/RegionRT.cpp | 6 ------ src/pluginsRT/ReorgRT.cpp | 4 ---- src/pluginsRT/ReshapeRT.cpp | 4 ---- src/pluginsRT/ShortcutRT.cpp | 7 ------- src/pluginsRT/UpsampleRT.cpp | 4 ---- src/pluginsRT/YoloRT.cpp | 13 ------------- 10 files changed, 2 insertions(+), 70 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index bfdb426..a574fe5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ if (CUDA_FOUND) #Get CUDA compute capability set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) - execute_process(COMMAND nvcc -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) + execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) execute_process(COMMAND ${OUTPUTFILE} RESULT_VARIABLE CUDA_RETURN_CODE OUTPUT_VARIABLE ARCH) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index fbfbb6f..c3afcda 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -40,7 +40,7 @@ int main(int argc, char *argv[]) { #ifdef __linux__ std::string input = "../demo/yolo_test.mp4"; #elif _WIN32 - std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; + std::string input = "..\\demo\\yolo_test.mp4"; #endif char ntype = 'y'; diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 1dc4d1a..1c1df84 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -291,31 +291,6 @@ bool DeformableConvRT::supportsFormat(DataType type, PluginFormat format) const DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("chunk_dim", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kh", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sh", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("ph", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("pw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("deformable_group", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_n", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_n", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("offset_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("ones_d2_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("ones_d1_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("data_d_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("bias2_d_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("height_ones", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("width_ones", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("dim_ones", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index c281579..53036ff 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -163,11 +163,6 @@ bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const N FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("rows", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("cols", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index 2d9899c..249c48a 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -170,12 +170,6 @@ void RegionRT::detachFromContext() NOEXCEPT { RegionRTPluginCreator::RegionRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("coords", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index b1e7b1f..e3a18df 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -133,10 +133,6 @@ void ReorgRT::detachFromContext() NOEXCEPT { ReorgRTPluginCreator::ReorgRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index 43cf8af..f026d3a 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -137,10 +137,6 @@ void ReshapeRT::detachFromContext() NOEXCEPT { ReshapeRTPluginCreator::ReshapeRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("n", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index ea18b0e..2a126bb 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -151,13 +151,6 @@ DataType ShortcutRT::getOutputDataType(int32_t index, const nvinfer1::DataType * ShortcutRTPluginCreator::ShortcutRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("bc", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("bh", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("bw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("mul", nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index 6859984..21ee95a 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -139,10 +139,6 @@ DataType UpsampleRT::getOutputDataType(int32_t index, const nvinfer1::DataType * UpsampleRTPluginCreator::UpsampleRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index aa99415..3612c4e 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -242,19 +242,6 @@ void YoloRT::detachFromContext() NOEXCEPT { YoloRTPluginCreator::YoloRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("classNames", nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("bias_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("n_masks", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("scaleXy", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nms_thresh", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nms_kind", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("new_coords", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } -- 2.52.0 From d2d44e9e92a86849b4754b416d635a908c341290 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Thu, 4 Nov 2021 19:28:55 +0100 Subject: [PATCH 20/58] Fix max elem (remove thrust) for segmentation Signed-off-by: Micaela Verucchi --- src/kernels/postprocessing.cu | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) 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){ -- 2.52.0 From 744396fb0e60e3873307ac1be1d1fc430bb9ee5c Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 9 Nov 2021 13:37:26 +0530 Subject: [PATCH 21/58] Update README.md,windows.md and demo.cpp Small fixes in DeformableConvRT.cpp --- CMakeLists.txt | 18 ++++++++++++------ README.md | 9 +++++---- demo/demo/demo.cpp | 12 ++++++------ docs/demo.md | 30 +++++++++++++++++++----------- docs/windows.md | 25 ++++++++++++++++--------- src/pluginsRT/DeformableConvRT.cpp | 5 +++-- 6 files changed, 61 insertions(+), 38 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a574fe5..cbb2fb6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,10 +3,12 @@ project(tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) set(CMAKE_CXX_STANDARD 14) +option(ENABLE_OPENCV_CUDA_CONTRIB "Enable OpenCV CUDA Contrib" OFF ) + find_package(CUDA 9.0 REQUIRED) if (CUDA_FOUND) - #Get CUDA compute capability 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} @@ -25,10 +27,7 @@ if (CUDA_FOUND) 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}") - add_definitions(-DGPU) #You may not require this - else() message(WARNING ${ARCH}) endif() @@ -51,7 +50,7 @@ endif() if(WIN32) if(CMAKE_BUILD_TYPE MATCHES Release) - set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc /Md") + set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc /MD") set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) endif() @@ -70,7 +69,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}") @@ -105,6 +104,13 @@ 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) + add_compile_definitions(OPENCV_CUDACONTRIB) + message("OpenCV Cuda Contrib modules found") + endif() +endif() # if(OpenCV_CUDA_VERSION) # add_compile_definitions(OPENCV_CUDACONTRIB) # endif() diff --git a/README.md b/README.md index b630fec..2aea96a 100644 --- a/README.md +++ b/README.md @@ -104,14 +104,15 @@ 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. ## 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,7 +137,7 @@ 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/11 (experimental) For specific details on how to run tkDNN on Windows 10 see [HERE](./docs/windows.md). diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index c3afcda..967c996 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -45,16 +45,16 @@ int main(int argc, char *argv[]) { char ntype = 'y'; if(argc > 2) - ntype = argv[2][0]; - int n_classes = 80; + input = argv[2]; if(argc > 3) - n_classes = atoi(argv[3]); + ntype = argv[3][0]; + int n_classes = 80; if(argc > 4) - cfgPath = argv[4]; + n_classes = atoi(argv[4]); if(argc > 5) - namePath = argv[5]; + cfgPath = argv[5]; if(argc > 6) - input = argv[6]; + namePath = argv[6]; int n_batch = 1; if(argc > 7) n_batch = atoi(argv[7]); diff --git a/docs/demo.md b/docs/demo.md index cc93dd4..93f3691 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -26,27 +26,35 @@ 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(yolo) : ``` -./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y +./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/cococ.names ``` + +To run demo for mobilenet and centernet for the created rt file : +``` +./demo mobilenetv2ssd_fp32.rt m 20 +``` + In general the demo program takes 7 parameters: ``` -./demo +./demo ``` where -* `````` 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. +* `````` 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 +* ``` ```is the relative path to the config file (only for darknet based networks) used to train the network +* ``````is the relative path to the names file (only for darknet based networks) used to train the network +* `````` 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. N.B. By default it is used FP32 inference diff --git a/docs/windows.md b/docs/windows.md index 60813c5..7ea52b1 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 +* 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/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 1c1df84..9b7222d 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -65,7 +65,6 @@ DeformableConvRT::~DeformableConvRT() { checkCuda( cudaFree(offset) ); checkCuda( cudaFree(mask) ); checkCuda( cudaFree(ones_d2) ); - cublasDestroy(handle); } DeformableConvRT::DeformableConvRT(const void *data, size_t length) { @@ -229,7 +228,9 @@ void DeformableConvRT::serialize(void *buffer) const NOEXCEPT { assert(buf == a + getSerializationSize()); } -void DeformableConvRT::destroy() NOEXCEPT { delete this; } +void DeformableConvRT::destroy() NOEXCEPT { + delete this; +} const char *DeformableConvRT::getPluginNamespace() const NOEXCEPT { -- 2.52.0 From c0e209739733b3b63ecbff79c03c9ce98b8eeda5 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 10 Nov 2021 12:30:57 +0530 Subject: [PATCH 22/58] - CMakeLists.txt opencv cuda contrib autodetect - Updated Docker to cuda-11.3+cudnn-8.2.1+TensorRT-8.0.34,Ubuntu to 20.04 and OpenCV to 4.5.4 - Updated OpenCV4 to 4.5.4 in install_OpenCV4.sh - Updated README.md --- CMakeLists.txt | 9 +++++-- README.md | 24 ++++++++--------- docker/Dockerfile.base | 32 +++++++++++------------ docs/demo.md | 14 +++++----- docs/windows.md | 2 +- scripts/install_OpenCV4.sh | 10 +++++-- tests/centernet/dla34_cnet/dla34_cnet.cpp | 8 +++--- 7 files changed, 55 insertions(+), 44 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cbb2fb6..e90d975 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -107,8 +107,13 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOPENCV") if(ENABLE_OPENCV_CUDA_CONTRIB) if (OpenCV_FOUND) find_package(OpenCV COMPONENTS cudawarping cudaarithm) - add_compile_definitions(OPENCV_CUDACONTRIB) - message("OpenCV Cuda Contrib modules found") + 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) diff --git a/README.md b/README.md index 2aea96a..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,7 +100,8 @@ 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). @@ -137,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/11 (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/docker/Dockerfile.base b/docker/Dockerfile.base index e61b0d3..8abb594 100644 --- a/docker/Dockerfile.base +++ b/docker/Dockerfile.base @@ -1,16 +1,14 @@ -FROM nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04 +FROM nvidia/cuda:11.3.1-devel-ubuntu20.04 LABEL maintainer "Francesco Gatti" - -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 +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update && apt-get install 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 +RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt install -y git wget libeigen3-dev libyaml-cpp-dev gcc-9 g++-9 libopengl-dev libgl-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 - + wget https://github.com/Kitware/CMake/releases/download/v3.21.4/cmake-3.21.4-Linux-x86_64.sh && \ + chmod +x cmake-3.21.4-Linux-x86_64.sh && \ + ./cmake-3.21.4-Linux-x86_64.sh --prefix=/usr/local --exclude-subdir --skip-license && \ + rm ./cmake-3.21.4-Linux-x86_64.sh +ENV NVIDIA_VISIBLE_DEVICES all RUN echo "INSTALL OPENCV" RUN apt-get install -y build-essential \ unzip \ @@ -26,20 +24,21 @@ RUN apt-get install -y build-essential \ libx264-dev \ libgtk-3-dev \ libatlas-base-dev \ - gfortran \ + gfortran-9 \ + libtbb-dev \ 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 && wget https://github.com/opencv/opencv/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz +RUN cd && wget https://github.com/opencv/opencv_contrib/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz RUN cd && \ - cd opencv-4.3.0 && mkdir build && 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='~/opencv_contrib-4.5.4/modules' \ -D BUILD_EXAMPLES=OFF \ -D WITH_CUDA=ON \ -D CUDA_ARCH_BIN=7.2 \ @@ -47,6 +46,7 @@ RUN cd && \ -D ENABLE_FAST_MATH=ON \ -D CUDA_FAST_MATH=ON \ -D WITH_CUBLAS=ON \ + -D WITH_OPENMP=ON \ -D WITH_LIBV4L=ON \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ diff --git a/docs/demo.md b/docs/demo.md index 93f3691..b14baf7 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -32,7 +32,7 @@ make Once you have successfully created your rt file, run the demo(yolo) : ``` -./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/cococ.names +./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names ``` To run demo for mobilenet and centernet for the created rt file : @@ -67,9 +67,9 @@ 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) +./demo yolo4_fp16.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names ``` N.B. Using FP16 inference will lead to some errors in the results (first or second decimal). @@ -92,9 +92,9 @@ 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) +./demo yolo4_int8.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names ``` N.B. diff --git a/docs/windows.md b/docs/windows.md index 7ea52b1..fced442 100644 --- a/docs/windows.md +++ b/docs/windows.md @@ -13,7 +13,7 @@ ### Dependencies-Windows This branch should work on every NVIDIA GPU supported in windows with the following dependencies: -* WINDOWS 10 1803 or HIGHER +* WINDOWS 10 1803/WINDOWS 11 or HIGHER * CUDA 11.2 * CUDNN 8.1.1 * TENSORRT 7.2.3 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/tests/centernet/dla34_cnet/dla34_cnet.cpp b/tests/centernet/dla34_cnet/dla34_cnet.cpp index 303c30a..3763f0f 100644 --- a/tests/centernet/dla34_cnet/dla34_cnet.cpp +++ b/tests/centernet/dla34_cnet/dla34_cnet.cpp @@ -492,7 +492,7 @@ int main() // } //convert network to tensorRT - tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("dla34_cnet")); + tk::dnn::NetworkRT *netRT = new tk::dnn::NetworkRT(&net, net.getNetworkRTName("dla34_cnet")); tk::dnn::dataDim_t dim1 = dim; //input dim printCenteredTitle(" CUDNN inference ", '=', 30); @@ -509,7 +509,7 @@ int main() { dim2.print(); TKDNN_TSTART - netRT.infer(dim2, data); + netRT->infer(dim2, data); TKDNN_TSTOP dim2.print(); } @@ -528,7 +528,7 @@ int main() dnnType *cudnn_out, *rt_out; cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT.buffersRT[i+out_count]; + rt_out = (dnnType *)netRT->buffersRT[i+out_count]; // there is the maxpool. It isn't an output but it is necessary for the process section if(i==0) out_count ++; @@ -540,6 +540,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } - netRT.destroy(); + netRT->destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } -- 2.52.0 From 936b680f2fed527a67c313abc17a2c3e4dd1ed3e Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 10 Nov 2021 13:45:44 +0530 Subject: [PATCH 23/58] Remove debug prints --- src/pluginsRT/YoloRT.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 3612c4e..4ef62b7 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -31,7 +31,6 @@ YoloRT::YoloRT(int classes, int num, int c,int h,int w,std::vector YoloRT::YoloRT(const void *data, size_t length) { std::vector maskTemp,biasTemp; - std::cout<<"LENGTH : "<(data),*bufCheck = buf; classes = readBUF(buf); num = readBUF(buf); @@ -160,7 +159,6 @@ 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; - std::cout< Date: Wed, 10 Nov 2021 14:37:16 +0530 Subject: [PATCH 24/58] added assert for supportsFormat in plugins --- src/pluginsRT/ActivationMishRT.cpp | 2 +- src/pluginsRT/DeformableConvRT.cpp | 2 +- src/pluginsRT/FlattenConcatRT.cpp | 2 +- src/pluginsRT/MaxPoolingSizeRT.cpp | 3 +-- src/pluginsRT/RegionRT.cpp | 2 +- src/pluginsRT/ReorgRT.cpp | 2 +- src/pluginsRT/ReshapeRT.cpp | 3 +-- src/pluginsRT/ResizeLayerRT.cpp | 3 +-- src/pluginsRT/RouteRT.cpp | 3 +-- src/pluginsRT/ShortcutRT.cpp | 2 +- src/pluginsRT/UpsampleRT.cpp | 2 +- src/pluginsRT/YoloRT.cpp | 2 +- 12 files changed, 12 insertions(+), 16 deletions(-) diff --git a/src/pluginsRT/ActivationMishRT.cpp b/src/pluginsRT/ActivationMishRT.cpp index d42b90a..f92629b 100644 --- a/src/pluginsRT/ActivationMishRT.cpp +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -73,7 +73,7 @@ const char *ActivationMishRT::getPluginVersion() const NOEXCEPT { } bool ActivationMishRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ActivationMishRT::getPluginNamespace() const NOEXCEPT { diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 9b7222d..6af3587 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -287,7 +287,7 @@ void DeformableConvRT::detachFromContext() NOEXCEPT { } bool DeformableConvRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 53036ff..0e500b3 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -158,7 +158,7 @@ FlattenConcatRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const } bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp index 5f36ae3..c45eae3 100644 --- a/src/pluginsRT/MaxPoolingSizeRT.cpp +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -93,8 +93,7 @@ delete this; } bool MaxPoolFixedSizeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *MaxPoolFixedSizeRT::getPluginNamespace() const NOEXCEPT { diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index 249c48a..c31bbe6 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -131,7 +131,7 @@ void RegionRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { } bool RegionRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } IPluginV2Ext *RegionRT::clone() const NOEXCEPT { diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index e3a18df..8f0fa12 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -75,7 +75,7 @@ void ReorgRT::serialize(void *buffer) const NOEXCEPT { } bool ReorgRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ReorgRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index f026d3a..8d81a8d 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -76,8 +76,7 @@ void ReshapeRT::serialize(void *buffer) const NOEXCEPT { } bool ReshapeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ReshapeRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp index db98326..1068f60 100644 --- a/src/pluginsRT/ResizeLayerRT.cpp +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -77,8 +77,7 @@ void ResizeLayerRT::serialize(void *buffer) const NOEXCEPT { } bool ResizeLayerRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ResizeLayerRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/RouteRT.cpp b/src/pluginsRT/RouteRT.cpp index 3218622..3c3ca79 100644 --- a/src/pluginsRT/RouteRT.cpp +++ b/src/pluginsRT/RouteRT.cpp @@ -131,8 +131,7 @@ void RouteRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { } bool RouteRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } IPluginV2 *RouteRT::clone() const NOEXCEPT { diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index 2a126bb..606f66e 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -91,7 +91,7 @@ void ShortcutRT::serialize(void *buffer) const NOEXCEPT { } bool ShortcutRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ShortcutRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index 21ee95a..af21bc0 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -81,7 +81,7 @@ void UpsampleRT::serialize(void *buffer) const NOEXCEPT { } bool UpsampleRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *UpsampleRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 4ef62b7..9585754 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -152,7 +152,7 @@ size_t YoloRT::getSerializationSize() const NOEXCEPT { } bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } void YoloRT::serialize(void *buffer) const NOEXCEPT { -- 2.52.0 From 9e328c0daa159de69d744ea71e0b61d053c363c5 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 10 Nov 2021 20:09:57 +0530 Subject: [PATCH 25/58] Migrate tkDNN max pooling plugin creation to pluginRegistry from the default method --- include/tkDNN/Layer.h | 1 + src/NetworkRT.cpp | 17 +++++++++++++++-- src/Pooling.cpp | 1 + src/pluginsRT/MaxPoolingSizeRT.cpp | 11 +++++++---- 4 files changed, 24 insertions(+), 6 deletions(-) diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index e09e5fa..5273c83 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -500,6 +500,7 @@ public: int winH, winW; int strideH, strideW; int paddingH, paddingW; + int padding; bool size; tkdnnPoolingMode_t pool_mode; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index dc2e337..472b5dd 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -369,8 +369,21 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { if(l->pool_mode == tkdnnPoolingMode_t::POOLING_MAX_FIXEDSIZE) { - IPluginV2 *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); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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; } 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/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp index c45eae3..4254ac5 100644 --- a/src/pluginsRT/MaxPoolingSizeRT.cpp +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -4,6 +4,9 @@ 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; @@ -105,11 +108,11 @@ void MaxPoolFixedSizeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEP } const char *MaxPoolFixedSizeRT::getPluginType() const NOEXCEPT { - return "MaxPoolingFixedSizeRT_tkDNN"; + return MAXPOOLFIXEDSIZERT_PLUGIN_NAME; } const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { - return "1"; + return MAXPOOLFIXEDSIZERT_PLUGIN_VERSION; } IPluginV2Ext *MaxPoolFixedSizeRT::clone() const NOEXCEPT { @@ -185,11 +188,11 @@ IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, co } const char *MaxPoolFixedSizeRTPluginCreator::getPluginName() const NOEXCEPT { - return "MaxPoolingFixedSizeRT_tkDNN"; + return MAXPOOLFIXEDSIZERT_PLUGIN_NAME; } const char *MaxPoolFixedSizeRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return MAXPOOLFIXEDSIZERT_PLUGIN_VERSION; } const PluginFieldCollection *MaxPoolFixedSizeRTPluginCreator::getFieldNames() NOEXCEPT { -- 2.52.0 From ee5000ccca696371f1a09c4c2979548a9375c7a5 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 13 Nov 2021 02:00:49 +0530 Subject: [PATCH 26/58] bug fixes for dla networks and ported optimization from different pull request --- CMakeLists.txt | 27 ---- include/tkDNN/NetworkRT.h | 14 +- include/tkDNN/pluginsRT/YoloRT.h | 5 +- src/NetworkRT.cpp | 41 +++--- src/pluginsRT/YoloRT.cpp | 57 ++------ tests/centernet/dla34_cnet/dla34_cnet.cpp | 8 +- tests/shelfnet/shelfnet_berkeley.cpp | 162 +++++++++++----------- 7 files changed, 122 insertions(+), 192 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e90d975..be3be48 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,36 +6,9 @@ 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") diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 94a60f3..cd297ab 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -48,7 +48,7 @@ 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; @@ -84,14 +84,14 @@ 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); bool serialize(const char *filename); diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 42ebcc7..352a0cb 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -13,8 +13,7 @@ namespace nvinfer1 { class YoloRT : public IPluginV2Ext { public: - YoloRT(int classes, int num,int c,int h,int w,std::vector classNames, - std::vector masks_v,std::vector bias_v, int n_masks = 3, float scale_xy = 1, + 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); @@ -84,8 +83,6 @@ namespace nvinfer1 { int NUM = 0; std::vector classesNames; - std::vector mask; - std::vector bias; int entry_index(int batch, int location, int entry) { int n = location / (w * h); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 472b5dd..6de297a 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -148,8 +148,10 @@ NetworkRT::NetworkRT(Network *net, const char *name) { // we don't need the network any more //networkRT->destroy(); std::cout<<"serialize net\n"; + builderActive = true; serialize(name); } else { + builderActive = false; deserialize(name); } @@ -386,6 +388,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; + } else { @@ -433,14 +436,15 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { return lRT; } else if(l->act_mode == ACTIVATION_MISH) { - IPluginV2 *plugin = new ActivationMishRT(); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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) { - IPluginV2 *plugin = new ActivationLogisticRT(); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kSIGMOID); checkNULL(lRT); return lRT; } @@ -484,7 +488,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { auto creator = getPluginRegistry()->getPluginCreator("FlattenConcatRT_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -495,14 +499,13 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { 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"; auto creator = getPluginRegistry()->getPluginCreator("ReshapeRT_tkDNN","1"); std::vector mPluginAttributes; @@ -530,7 +533,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Resize *l) { 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"; @@ -549,7 +552,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { 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"; @@ -608,10 +611,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { } } -ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { - std::vector mask_h(l->mask_h,l->mask_h+sizeof(dnnType)*l->n_masks); - std::vector bias_h(l->bias_h,l->bias_h+sizeof(dnnType)*2*l->n_masks*l->num); auto creator = getPluginRegistry()->getPluginCreator("YoloRT_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -620,9 +621,6 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { 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("classNames",&l->classesNames[0],PluginFieldType::kUNKNOWN,l->classesNames.size())); - mPluginAttributes.emplace_back(PluginField("mask_v",&mask_h[0],PluginFieldType::kFLOAT32,mask_h.size())); - mPluginAttributes.emplace_back(PluginField("bias_v",&bias_h[0],PluginFieldType::kFLOAT32,bias_h.size())); 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)); @@ -636,9 +634,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; - auto creator = getPluginRegistry()->getPluginCreator("UpSample_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -789,8 +786,10 @@ bool NetworkRT::deserialize(const char *filename) { void NetworkRT::destroy() { contextRT->destroy(); - engineRT->destroy(); - builderRT->destroy(); + if(builderActive) { + engineRT->destroy(); + builderRT->destroy(); + } } }} diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 9585754..55cb462 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -9,8 +9,7 @@ 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,std::vector classNames, - std::vector masks_v,std::vector bias_v,int n_masks, float scale_xy, +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; @@ -23,14 +22,9 @@ YoloRT::YoloRT(int classes, int num, int c,int h,int w,std::vector this->nms_thresh = nms_thresh; this->nms_kind = nms_kind; this->new_coords = new_coords; - this->classesNames = std::move(classNames); - this->mask = std::move(masks_v); - this->bias = std::move(bias_v); - } YoloRT::YoloRT(const void *data, size_t length) { - std::vector maskTemp,biasTemp; const char* buf = reinterpret_cast(data),*bufCheck = buf; classes = readBUF(buf); num = readBUF(buf); @@ -42,21 +36,6 @@ YoloRT::YoloRT(const void *data, size_t length) { c = readBUF(buf); h = readBUF(buf); w = readBUF(buf); - mask.resize(n_masks); - for(int i=0;i(buf); - } - bias.resize(n_masks*2*num); - for(int i=0;i(buf); - } - classesNames.resize(classes); - for(int i=0;i(buf); - classesNames[1] = std::string(tmp); - } assert(buf == bufCheck + length); } @@ -147,8 +126,7 @@ int32_t YoloRT::enqueue(int32_t batchSize, const void *const *inputs, void **out size_t YoloRT::getSerializationSize() const NOEXCEPT { - return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + - YOLORT_CLASSNAME_W * classes * sizeof(char); + return 8 * sizeof(int) + 2 * sizeof(float) ; } bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { @@ -167,21 +145,7 @@ void YoloRT::serialize(void *buffer) const NOEXCEPT { 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; - for (int i = 0; i < n_masks; i++) { - writeBUF(buf, mask[i]); //std::cout << "mask[i] : " << mask[i] << std::endl; - } - for (int i = 0; i < n_masks * 2 * num; i++) { - writeBUF(buf, bias[i]); //std::cout << "bias[i] : " << bias[i] << std::endl; - } - // save classes names - for (int i = 0; i < classes; i++) { - char tmp[YOLORT_CLASSNAME_W]; - strcpy(tmp, classesNames[i].c_str()); - for (int j = 0; j < YOLORT_CLASSNAME_W; j++) { - writeBUF(buf, tmp[j]); - } - } assert(buf == a + getSerializationSize()); } @@ -206,7 +170,7 @@ void YoloRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { } IPluginV2Ext *YoloRT::clone() const NOEXCEPT { - auto *p = new YoloRT(classes, num,c,h,w,classesNames,mask,bias, n_masks, scaleXY, nms_thresh, nms_kind, new_coords); + 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; } @@ -265,15 +229,12 @@ IPluginV2Ext *YoloRTPluginCreator::createPlugin(const char *name, const PluginFi int c = *(static_cast(fields[2].data)); int h = *(static_cast(fields[3].data)); int w = *(static_cast(fields[4].data)); - std::vector classNames(static_cast(fields[5].data),static_cast(fields[5].data) + fields[5].length); - std::vector mask_v(static_cast(fields[6].data),static_cast(fields[6].data) + fields[6].length); - std::vector bias_v(static_cast(fields[7].data),static_cast(fields[7].data) + fields[7].length); - int n_masks = *(static_cast(fields[8].data)); - dnnType scaleXY = *(static_cast(fields[9].data)); - dnnType nmsThresh = *(static_cast(fields[10].data)); - int nms_kind = *(static_cast(fields[11].data)); - int new_coords = *(static_cast(fields[12].data)); - auto *pluginObj = new YoloRT(classes,num,c,h,w,classNames,mask_v,bias_v,n_masks,scaleXY,nmsThresh,nms_kind,new_coords); + 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; } diff --git a/tests/centernet/dla34_cnet/dla34_cnet.cpp b/tests/centernet/dla34_cnet/dla34_cnet.cpp index 3763f0f..303c30a 100644 --- a/tests/centernet/dla34_cnet/dla34_cnet.cpp +++ b/tests/centernet/dla34_cnet/dla34_cnet.cpp @@ -492,7 +492,7 @@ int main() // } //convert network to tensorRT - tk::dnn::NetworkRT *netRT = new tk::dnn::NetworkRT(&net, net.getNetworkRTName("dla34_cnet")); + tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("dla34_cnet")); tk::dnn::dataDim_t dim1 = dim; //input dim printCenteredTitle(" CUDNN inference ", '=', 30); @@ -509,7 +509,7 @@ int main() { dim2.print(); TKDNN_TSTART - netRT->infer(dim2, data); + netRT.infer(dim2, data); TKDNN_TSTOP dim2.print(); } @@ -528,7 +528,7 @@ int main() dnnType *cudnn_out, *rt_out; cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT->buffersRT[i+out_count]; + rt_out = (dnnType *)netRT.buffersRT[i+out_count]; // there is the maxpool. It isn't an output but it is necessary for the process section if(i==0) out_count ++; @@ -540,6 +540,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } - netRT->destroy(); + 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 bacb507..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); - netRT.destroy(); + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; -} +} \ No newline at end of file -- 2.52.0 From d488c3bd1780e9df228a22b0babc89fb4a6019a4 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 13 Nov 2021 02:12:50 +0530 Subject: [PATCH 27/58] remove duplicated lines --- src/NetworkRT.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 6de297a..743f536 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -55,13 +55,13 @@ 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); - configRT->setMaxWorkspaceSize(1 << 30); if(net->fp16 && builderRT->platformHasFastFp16()) { dtRT = DataType::kHALF; -- 2.52.0 From 367061fea22736101e08eeb42fe2e28c505b5a65 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 13 Nov 2021 18:11:46 +0530 Subject: [PATCH 28/58] fps fix --- src/NetworkRT.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 743f536..709b9b2 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -430,9 +430,13 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { return lRT; } else if(l->act_mode == CUDNN_ACTIVATION_CLIPPED_RELU) { - IPluginV2 *plugin = new ActivationReLUCeiling(l->ceiling); - IPluginV2Layer *lRT = networkRT->addPluginV2(&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) { -- 2.52.0 From 6f936096aeac6188fc3f51a372e0d76792124e2a Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 14 Nov 2021 07:13:42 +0530 Subject: [PATCH 29/58] Added num of layers in net and netRT,suggestions from pull request 270 on main repo --- CMakeLists.txt | 26 ++++++++++++++++++++++++++ include/tkDNN/NetworkRT.h | 2 ++ src/NetworkRT.cpp | 6 +++++- 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index be3be48..7cc9e33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,32 @@ 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) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index cd297ab..ddd3d9f 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -24,6 +24,8 @@ #include #include + + namespace tk { namespace dnn { using namespace nvinfer1; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 709b9b2..2e9eb6e 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -183,7 +183,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); -- 2.52.0 From 19f12d9c1567662661df76e2e8c761cfc2579aa7 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 15 Nov 2021 00:08:37 +0530 Subject: [PATCH 30/58] rds_slam -> tensorrt8 port for rds --- include/tkDNN/SegmentationNN.h | 241 +++++++++++++++++++++++++++++++++ 1 file changed, 241 insertions(+) diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index 403bc28..fff27a8 100644 --- a/include/tkDNN/SegmentationNN.h +++ b/include/tkDNN/SegmentationNN.h @@ -18,6 +18,7 @@ #include "tkdnn.h" #include "NetworkViz.h" #include "kernelsThrust.h" +#define SLAM_MODE namespace tk { namespace dnn { @@ -99,6 +100,62 @@ class SegmentationNN { * * @param bi batch index */ + + #ifdef SLAM_MODE + cv::Mat postprocess(const int bi=0,bool apply_colormap=true){ + cv::Mat maskMatrix; + dnnType *rt_out = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[1].tot()*bi; + + dataDim_t odim = netRT->output_dim; + + matrixTranspose(cublasHandle, rt_out, tmpInputData_d, odim.c, odim.w*odim.h); + maxElem(tmpInputData_d, tmpOutData_d, odim.c, odim.h, odim.w); + checkCuda(cudaMemcpy(tmpOutData_h, tmpOutData_d, odim.w*odim.h * sizeof(float), cudaMemcpyDeviceToHost)); + + + + dataDim_t vdim = odim; + vdim.c = 1; + dnnType *dataTemp = nullptr; + if(isCudaPointer(tmpOutData_h)) + { + dataTemp = new dnnType[vdim.tot()]; + checkCuda(cudaMemcpy(dataTemp,tmpOutData_h,vdim.tot()*sizeof(dnnType),cudaMemcpyDeviceToHost)); + } + else + { + dataTemp = tmpOutData_h; + } + for(int i =0;iinput_dim.h, netRT->input_dim.w, 0, classes, classes); + else{ + cv::Mat colored_fp32 (cv::Size(odim.w, odim.h),CV_32FC1, dataTemp); + colored_fp32.convertTo(colored, CV_8UC1); + } + + int max_dim = (originalSize[bi].width > originalSize[bi].height) ? originalSize[bi].width : originalSize[bi].height; + resize(colored, colored, cv::Size(max_dim, max_dim)); + int top, bottom, left, right; + computeBorders(originalSize[bi].width, originalSize[bi].height, top, bottom, left, right); + cv::Rect roi(left,top,originalSize[bi].width, originalSize[bi].height); + cv::Mat or_size (colored, roi); + segmented[bi] = or_size; + + if(isCudaPointer(tmpOutData_h)) + { + delete [] dataTemp; + } + + return maskMatrix; + + } + #elif + void postprocess(const int bi=0, bool appy_colormap = true) { dnnType *rt_out = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[1].tot()*bi; @@ -128,6 +185,7 @@ class SegmentationNN { cv::Mat or_size (colored, roi); segmented[bi] = or_size; }; + #endif public: int classes = 0; @@ -237,6 +295,184 @@ class SegmentationNN { } } + #ifdef SLAM_MODE + cv::Mat updateOriginal(cv::Mat frame,bool apply_colormap=true){ + std::vector splitted_frames; + cv::Mat maskMatrix; + int H, W, net_H, net_W; + int top = 0, bottom = 0, left = 0, right = 0; + std::vector> pos; + + { + TKDNN_TSTART + cv::Size original_size = frame.size(); + + frame.convertTo(frame, CV_32FC3, 1 / 255.0, 0); + H = frame.rows; + W = frame.cols; + net_H = netRT->input_dim.h; + net_W = netRT->input_dim.w; + + cv::Mat frame_cropped; + + if( H <= net_H && W <= net_W ){ // smaller size wrt network + top = (net_H - H)/2; + bottom = net_H - H - top ; + left = (net_W - W)/2; + right = net_W - W - left ; + cv::copyMakeBorder(frame, frame_cropped, top, bottom, left, right, cv::BORDER_CONSTANT, cv::Scalar(0,0,0) ); + splitted_frames.push_back(frame_cropped); + } + else{ //bigger size wrt network + + + if(H < net_H || W < net_W){ + if(H < net_H){ + top = (net_H - H)/2; + bottom = net_H - H - top ; + } + else{ + left = (net_W - W)/2; + right = net_W - W - left ; + } + cv::copyMakeBorder(frame, frame_cropped, top, bottom, left, right, cv::BORDER_CONSTANT, cv::Scalar(0,0,0)); + } + + for(int x=0; x+net_W<=W ;){ + for(int y=0; y+net_H <=H ; ){ + cv::Rect roi(x, y, net_W, net_H); + cv::Mat image_roi = frame(roi); + splitted_frames.push_back(image_roi); + pos.push_back(std::make_pair(x,y)); + + y += net_H; + if(y == H) + break; + if(y + net_H > H) y = H - net_H; + } + x += net_W; + if(x == W) + break; + if(x + net_W > W) x = W - net_W; + } + } + + tk::dnn::dataDim_t idim = netRT->input_dim; + + if(splitted_frames.size()> nBatches) + FatalError(std::to_string(splitted_frames.size()) + " min batches required"); + + for(int bi=0; bistream)); + normalize(input_d + idim.tot()*bi, idim.c, idim.h, idim.w, mean_d, stddev_d); + } + TKDNN_TSTOP + stats_pre.push_back(t_ns); + } + + tk::dnn::dataDim_t dim = netRT->input_dim; + dim.n = splitted_frames.size(); + { + if(TKDNN_VERBOSE) dim.print(); + TKDNN_TSTART + netRT->infer(dim, input_d); + TKDNN_TSTOP + if(TKDNN_VERBOSE) dim.print(); + stats.push_back(t_ns); + } + + dataDim_t odim = netRT->output_dim; + + std::vector out_img; + std::vector out_mask; + + { + TKDNN_TSTART + + for(int bi=0; bibuffersRT[1]+ netRT->buffersDIM[1].tot()*bi; + + matrixTranspose(cublasHandle, rt_out, tmpInputData_d, odim.c, odim.w*odim.h); + maxElem(tmpInputData_d, tmpOutData_d, odim.c, odim.h, odim.w); + checkCuda(cudaMemcpy(tmpOutData_h, tmpOutData_d, odim.w*odim.h * sizeof(float), cudaMemcpyDeviceToHost)); + + dataDim_t vdim = odim; + vdim.c = 1; + dnnType *dataTemp = nullptr; + if(isCudaPointer(tmpOutData_h)) + { + dataTemp = new dnnType[vdim.tot()]; + checkCuda(cudaMemcpy(dataTemp,tmpOutData_h,vdim.tot()*sizeof(dnnType),cudaMemcpyDeviceToHost)); + } + else + { + dataTemp = tmpOutData_h; + } + + cv::Mat colored; + for(int i=0;iinput_dim.h, netRT->input_dim.w, 0, classes, classes); + else{ + cv::Mat colored_fp32 (cv::Size(odim.w, odim.h),CV_32FC1, tmpOutData_h); + colored_fp32.convertTo(colored, CV_8UC1); + } + out_img.push_back(colored); + if(isCudaPointer(tmpOutData_h)) + { + delete [] dataTemp; + } + } + + cv::Mat tempMask(frame.size(), out_mask[0].type()); + cv::Mat seg(frame.size(), out_img[0].type()); + if(out_img.size() == 1) + { + cv::Rect roi(left, top, W, H); + seg = out_img[0](roi); + tempMask = out_mask[0](roi); + } + else{ + int bi=0; + + if(top == 0 && left == 0){ + + for(int i=0; i splitted_frames; @@ -385,6 +621,11 @@ class SegmentationNN { stats_post.push_back(t_ns); } } + #endif + + + + /** * Method to draw boundixg boxes and labels on a frame. -- 2.52.0 From a8c98e3c3101cb7446648eee93a99f6ff4810855 Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Fri, 19 Nov 2021 22:40:52 +0530 Subject: [PATCH 31/58] Signed-off-by: perseusdg <43143075+perseusdg@users.noreply.github.com> removed all TRT8_DEPRACTED functions --- include/tkDNN/NetworkRT.h | 5 +++ src/NetworkRT.cpp | 74 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 74 insertions(+), 5 deletions(-) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index ddd3d9f..cd9f649 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -96,7 +96,12 @@ public: 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/src/NetworkRT.cpp b/src/NetworkRT.cpp index 2e9eb6e..76c3205 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -137,12 +137,16 @@ 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 @@ -150,6 +154,19 @@ NetworkRT::NetworkRT(Network *net, const char *name) { 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); @@ -321,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); @@ -341,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) { @@ -396,12 +436,20 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { } 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 } } @@ -753,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); @@ -769,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) { @@ -793,10 +857,10 @@ bool NetworkRT::deserialize(const char *filename) { } void NetworkRT::destroy() { - contextRT->destroy(); + delete contextRT; if(builderActive) { - engineRT->destroy(); - builderRT->destroy(); + delete engineRT; + delete builderRT; } } -- 2.52.0 From 9cecc5051ae3e768da08962d44cc7ad7c0d2e26a Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Wed, 24 Nov 2021 03:39:57 +0530 Subject: [PATCH 32/58] -Modified Dockerfile.base to cudagl -Changed demo to take in input from demoConfig.yaml file -Readme changes for demo.md --- .gitignore | 1 + demo/demo/demo.cpp | 112 +++++++++++---------- demo/demoConfig.yaml | 22 +++++ docker/Dockerfile.base | 159 +++++++++++++++++++++++------- docker/README.md | 5 +- docker/assets/entrypoint_setup.sh | 123 +++++++++++++++++++++++ docker/assets/terminator_config | 18 ++++ docker/docker_launch.sh | 9 ++ docs/demo.md | 43 ++++---- include/tkDNN/utils.h | 17 +++- scripts/checkExecTimes.py | 37 +++++++ 11 files changed, 422 insertions(+), 124 deletions(-) create mode 100644 demo/demoConfig.yaml create mode 100755 docker/assets/entrypoint_setup.sh create mode 100644 docker/assets/terminator_config create mode 100755 docker/docker_launch.sh create mode 100644 scripts/checkExecTimes.py diff --git a/.gitignore b/.gitignore index 683834c..22f7f94 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,4 @@ scripts/COCO_val2017/* scripts/COCO_val2017.zip scripts/all_labels.txt /cmake/cuda_script +/cmake-build-debug/ diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 967c996..b1cf574 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -18,64 +18,57 @@ 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"; - #ifdef __linux__ - std::string cfgPath = "../tests/darknet/cfg/yolo4tiny.cfg"; - #elif _WIN32 - std::string cfgPath = "..\\tests\\darknet\\cfg\\yolo4tiny.cfg"; - #endif - - #ifdef __linux__ - std::string namePath = "../tests/darknet/names/coco.names"; - #elif _WIN32 - std::string namePath = "..\\tests\\darknet\\names\\coco.names"; - #endif - - 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 - - char ntype = 'y'; - if(argc > 2) - input = argv[2]; - if(argc > 3) - ntype = argv[3][0]; - int n_classes = 80; - if(argc > 4) - n_classes = atoi(argv[4]); - if(argc > 5) - cfgPath = argv[5]; - if(argc > 6) - namePath = argv[6]; - int n_batch = 1; - if(argc > 7) - n_batch = atoi(argv[7]); - bool show = true; - if(argc > 8) - show = atoi(argv[8]); - float conf_thresh=0.3; - if(argc >= 9) - conf_thresh = atof(argv[9]); - - if(n_batch < 1 || n_batch > 64) - FatalError("Batch dim not supported"); - - if(!show) - SAVE_RESULT = true; - - if(ntype == 'c' || ntype == 'm'){ - cfgPath = ""; - namePath = ""; - + if(argc > 1){ + config_file = argv[1]; } + + 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"); + float conf_thresh = YAMLgetConf(conf, "conf_thresh", 0.3); + bool show = YAMLgetConf(conf, "show", true); + bool save = YAMLgetConf(conf, "save", false); + + + + + + + + tk::dnn::Yolo3Detection yolo; tk::dnn::CenternetDetection cnet; tk::dnn::MobilenetDetection mbnet; @@ -98,6 +91,11 @@ int main(int argc, char *argv[]) { FatalError("Network type not allowed (3rd parameter)\n"); } + if(ntype == 'c' || ntype == 'm'){ + cfgPath = ""; + namePath = ""; + } + detNN->init(net,cfgPath,namePath,n_classes,n_batch,conf_thresh); gRun = true; @@ -109,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)); @@ -149,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; } @@ -157,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: "<> /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 -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-9 \ - libtbb-dev \ - libgstreamer1.0-dev \ - libgstreamer-plugins-base1.0-dev \ - libdc1394-22-dev \ - libavresample-dev -RUN cd && wget https://github.com/opencv/opencv/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz -RUN cd && wget https://github.com/opencv/opencv_contrib/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz -RUN cd && \ +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.5.4/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 b14baf7..bf6b79d 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -30,31 +30,24 @@ cmake .. -DCMAKE_BUILD_TYPE=Debug -DDEBUG=True make ``` -Once you have successfully created your rt file, run the demo(yolo) : +Once you have successfully created your rt file, run the demo: ``` -./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names +./ demo ``` +In general the demo program takes 1 parameter, the `````` that is the path to che configuration file. The parameter is optional and its default value is ```"../demo/demoConfig.yaml"```. -To run demo for mobilenet and centernet for the created rt file : -``` -./demo mobilenetv2ssd_fp32.rt m 20 -``` - -In general the demo program takes 7 parameters: -``` -./demo -``` -where - -* `````` 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 -* ``` ```is the relative path to the config file (only for darknet based networks) used to train the network -* ``````is the relative path to the names file (only for darknet based networks) used to train the network -* `````` 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 @@ -69,7 +62,8 @@ To run the demo with FP16 inference follow these steps (example with yolov3): export TKDNN_MODE=FP16 # set the half floating point optimization rm yolo4_fp16.rt # be sure to delete(or move) old tensorRT files ./test_yolo4 # run the yolo test (is slow) -./demo yolo4_fp16.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names +#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). @@ -94,7 +88,8 @@ export TKDNN_CALIB_LABEL_PATH=../demo/COCO_val2017/all_labels.txt export TKDNN_CALIB_IMG_PATH=../demo/COCO_val2017/all_images.txt rm yolo4_int8.rt # be sure to delete(or move) old tensorRT files ./test_yolo4 # run the yolo test (is slow) -./demo yolo4_int8.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names +#set net: yolo4_int8.rt in the config file +./demo ``` N.B. diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 1219ec3..a1a1f1c 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -6,6 +6,8 @@ #include #include #include +#include + #include "cuda.h" #include "cuda_runtime_api.h" @@ -16,7 +18,6 @@ #ifdef __linux__ #include - #endif #include @@ -161,5 +162,19 @@ static inline bool isCudaPointer(void *data) { 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') + + -- 2.52.0 From bbae618118601fdee68e5a8c9913ca28d3ea39f9 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Wed, 24 Nov 2021 18:08:41 +0100 Subject: [PATCH 33/58] Update README and add print in demo Signed-off-by: Micaela Verucchi --- README.md | 14 ++++++++++---- demo/demo/demo.cpp | 14 ++++++++------ 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index d07ac42..af7c9c5 100644 --- a/README.md +++ b/README.md @@ -17,9 +17,15 @@ If you use tkDNN in your research, please cite the [following paper](https://iee } ``` -### What's new (November 2021) -- [x] Support to sematic segmentation on cuda 11+ [README](docs/README_seg.md) -- [x] Support to TensorRT8 +### 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) +#### 24 November 2021 +- [x] Support to sematic segmentation on cuda 11 +- [x] Support to TensorRT8. + +TensorRT8 (and therefore Jetpack 4.6) is currently supported only on the branch tensort8 due to [performance issue with TensorRT8](https://docs.nvidia.com/deeplearning/tensorrt/release-notes/tensorrt-8.html)). We will merge it to the master as soon as those issues are fixed (probably in future minor releases). ## FPS Results Inference FPS of yolov4 with tkDNN, average of 1200 images with the same dimension as the input size, on @@ -81,7 +87,7 @@ Results for COCO val 2017 (5k images), on RTX 2080Ti, with conf threshold=0.001 ## Dependencies This branch works on every NVIDIA GPU that supports the following (latest tested) dependencies: -* CUDA 11.3 (or >= 10.2) [the segmentation only works with CUDA 10 for now] +* CUDA 11.3 (or >= 10.2) * cuDNN 8.2.1 (or >= 8.0.4) * TensorRT 8.0.3 (or >=7.2) * OpenCV 4.5.4 (or >=4) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index b1cf574..6de7214 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -62,12 +62,14 @@ int main(int argc, char *argv[]) { bool show = YAMLgetConf(conf, "show", true); bool save = YAMLgetConf(conf, "save", false); - - - - - - + std::cout <<"Net settings - net: "<< net + <<", ntype: "<< ntype + <<", n_classes: "<< n_classes + <<", n_batch: "<< n_batch + <<", conf_thresh: "<< conf_thresh<<"\n"; + std::cout <<"Demo settings - input: "<< input + <<", show: "<< show + <<", save: "<< save<<"\n\n"; tk::dnn::Yolo3Detection yolo; tk::dnn::CenternetDetection cnet; -- 2.52.0 From a4781244f422de02f5ecd903a5ff834ddf7aae02 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Wed, 24 Nov 2021 18:16:15 +0100 Subject: [PATCH 34/58] Fix merge problem Signed-off-by: Micaela Verucchi --- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 42 +++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index ab97c10..1d98a59 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -42,5 +42,47 @@ namespace nvinfer1 { 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; + }; + + REGISTER_TENSORRT_PLUGIN(ActivationLeakyRTPluginCreator); }; \ No newline at end of file -- 2.52.0 From dcf4054bc638b9170ac0ef5145bded08a36c9bed Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Mon, 3 Jan 2022 13:52:16 +0530 Subject: [PATCH 35/58] performance improvements for yolo based networks,significant reduction in inference time can be seen yolo4tiny ,yolo4 and minor reduction in inference time can be seen in yolo4_berkeley_f1 and yolo4_berkeley - tested with a batchsize of 1 and 2 and on gtx 1070,it is possible that the performance improvement is more signficant in newer hardware --- include/tkDNN/NetworkRT.h | 2 +- src/NetworkRT.cpp | 99 ++++++++++++++++++++++----------------- 2 files changed, 57 insertions(+), 44 deletions(-) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index cd9f649..58a545a 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -93,7 +93,7 @@ public: nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Region *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Shortcut *l); nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Yolo *l); - nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Upsample *l); + nvinfer1::IResizeLayer* 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 diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 76c3205..ac1f23c 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -26,15 +26,15 @@ class Logger : public ILogger { namespace tk { namespace dnn { -std::maptensors; +std::maptensors; NetworkRT::NetworkRT(Network *net, const char *name) { - float rt_ver = float(NV_TENSORRT_MAJOR) + - float(NV_TENSORRT_MINOR)/10 + + float rt_ver = float(NV_TENSORRT_MAJOR) + + float(NV_TENSORRT_MINOR)/10 + float(NV_TENSORRT_PATCH)/100; std::cout<<"New NetworkRT (TensorRT v"<platformHasFastFp16()<<"\n"; std::cout<<"Int8 support: "<platformHasFastInt8()<<"\n"; @@ -42,12 +42,12 @@ NetworkRT::NetworkRT(Network *net, const char *name) { std::cout<<"DLAs: "<getNbDLACores()<<"\n"; #endif networkRT = builderRT->createNetworkV2(0U); -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 configRT = builderRT->createBuilderConfig(); #endif - + if(!fileExist(name)) { -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 // Calibrator life time needs to last until after the engine is built. std::unique_ptr calibrator; @@ -78,14 +78,14 @@ NetworkRT::NetworkRT(Network *net, const char *name) { configRT->setDLACore(0); } #endif -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 if(net->int8 && builderRT->platformHasFastInt8()){ // dtRT = DataType::kINT8; // builderRT->setInt8Mode(true); configRT->setFlag(BuilderFlag::kINT8); - BatchStream calibrationStream(dim, 1, 100, //TODO: check if 100 images are sufficient to the calibration (or 4951) + BatchStream calibrationStream(dim, 1, 100, //TODO: check if 100 images are sufficient to the calibration (or 4951) net->fileImgList, net->fileLabelList); - + /* The calibTableFilePath contains the path+filename of the calibration table. * Each calibration table can be found in the corresponding network folder (../Test/*). * Each network is located in a folder with the same name as the network. @@ -96,15 +96,15 @@ NetworkRT::NetworkRT(Network *net, const char *name) { if(!fileExist((const char *)calib_table_path.c_str())) calib_table_name = "./" + net->networkNameRT.substr(0, net->networkNameRT.find('.')) + "-calibration.table"; - calibrator.reset(new Int8EntropyCalibrator(calibrationStream, 1, - calib_table_name, + calibrator.reset(new Int8EntropyCalibrator(calibrationStream, 1, + calib_table_name, "data")); configRT->setInt8Calibrator(calibrator.get()); } #endif - + // add input layer - ITensor *input = networkRT->addInput("data", DataType::kFLOAT, + ITensor *input = networkRT->addInput("data", DataType::kFLOAT, Dims3{ dim.c, dim.h, dim.w}); checkNULL(input); @@ -112,17 +112,17 @@ NetworkRT::NetworkRT(Network *net, const char *name) { for(int i=0; inum_layers; i++) { Layer *l = net->layers[i]; ILayer *Ilay = convert_layer(input, l); -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 if(net->int8 && builderRT->platformHasFastInt8()) { Ilay->setPrecision(DataType::kINT8); } #endif Ilay->setName( (l->getLayerName() + std::to_string(i)).c_str() ); - + input = Ilay->getOutput(0); input->setName( (l->getLayerName() + std::to_string(i) + "_out").c_str() ); - + if(l->final) networkRT->markOutput(*input); tensors[l] = input; @@ -182,7 +182,7 @@ NetworkRT::NetworkRT(Network *net, const char *name) { // In order to bind the buffers, we need to know the names of the input and output tensors. // note that indices are guaranteed to be less than IEngine::getNbBindings() - buf_input_idx = engineRT->getBindingIndex("data"); + buf_input_idx = engineRT->getBindingIndex("data"); buf_output_idx = engineRT->getBindingIndex("out"); std::cout<<"input index = "< output index = "<data16_h; + data_b = l->data16_h; bias_b = l->bias16_h; } else { - data_b = l->data_h; + data_b = l->data_h; bias_b = l->bias_h; } @@ -308,7 +308,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { void *data_b, *bias_b, *bias2_b, *power_b, *mean_b, *variance_b, *scales_b; if(dtRT == DataType::kHALF) { - data_b = l->data16_h; + data_b = l->data16_h; bias_b = l->bias16_h; bias2_b = l->bias216_h; power_b = l->power16_h; @@ -316,7 +316,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { variance_b = l->variance16_h; scales_b = l->scales16_h; } else { - data_b = l->data_h; + data_b = l->data_h; bias_b = l->bias_h; bias2_b = l->bias2_h; power_b = l->power_h; @@ -332,7 +332,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { b = { dtRT, bias_b, l->outputs}; else{ if (l->additional_bias) - b = { dtRT, bias2_b, l->outputs}; + b = { dtRT, bias2_b, l->outputs}; else b = { dtRT, nullptr, 0}; //on batchnorm bias are added later } @@ -340,7 +340,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, + IConvolutionLayer *lRTconv = networkRT->addConvolution(*input, l->outputs, DimsHW{l->kernelH, l->kernelW}, w, b); checkNULL(lRTconv); lRTconv->setStride(DimsHW{l->strideH, l->strideW}); @@ -348,14 +348,14 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { lRTconv->setNbGroups(l->groups); lRT = (ILayer*) lRTconv; } else { - IDeconvolutionLayer *lRTconv = networkRT->addDeconvolution(*input, + IDeconvolutionLayer *lRTconv = networkRT->addDeconvolution(*input, l->outputs, DimsHW{l->kernelH, l->kernelW}, w, b); checkNULL(lRTconv); lRTconv->setStride(DimsHW{l->strideH, l->strideW}); lRTconv->setPadding(DimsHW{l->paddingH, l->paddingW}); lRTconv->setNbGroups(l->groups); lRT = (ILayer*) lRTconv; - + Dims d = lRTconv->getOutput(0)->getDimensions(); //std::cout<<"DECONV: "<outputs}; Weights scale{dtRT, variance_b, l->outputs}; // std::cout<getNbOutputs()<addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT2 = networkRT->addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, shift, scale, power); - + checkNULL(lRT2); Weights shift2{dtRT, bias_b, l->outputs}; Weights scale2{dtRT, scales_b, l->outputs}; - IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, shift2, scale2, power); checkNULL(lRT3); @@ -450,7 +450,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { lRT->setStrideNd(Dims2{l->strideH,l->strideW}); return lRT; #endif - } + } } ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { @@ -458,14 +458,14 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { if(l->act_mode == ACTIVATION_LEAKY) { //std::cout<<"New plugin LEAKY\n"; - -#if NV_TENSORRT_MAJOR < 6 + +#if NV_TENSORRT_MAJOR < 6 // plugin version IPlugin *plugin = new ActivationLeakyRT(l->slope); IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); checkNULL(lRT); return lRT; -#else +#else IActivationLayer *lRT = networkRT->addActivation(*input, ActivationType::kLEAKY_RELU); lRT->setAlpha(l->slope); checkNULL(lRT); @@ -490,7 +490,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { //IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); //checkNULL(lRT); return lRT; - } + } else if(l->act_mode == ACTIVATION_MISH) { IActivationLayer *lRT1 = networkRT->addActivation(*input, ActivationType::kSOFTPLUS); lRT1->setAlpha(1); @@ -504,6 +504,11 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { checkNULL(lRT); return lRT; } + else if(l->act_mode == CUDNN_ACTIVATION_ELU || l->act_mode == ACTIVATION_ELU){ + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kELU); + checkNULL(lRT); + return lRT; + } else { FatalError("this Activation mode is not yet implemented"); return NULL; @@ -521,7 +526,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Softmax *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { // std::cout<<"convert route\n"; - + ITensor **tens = new ITensor*[l->layers_n]; @@ -633,10 +638,10 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { //std::cout<<"convert Shortcut\n"; //std::cout<<"New plugin Shortcut\n"; - + ITensor *back_tens = tensors[l->backLayer]; - if(l->backLayer->output_dim.c == l->output_dim.c && !l->mul) + if(l->backLayer->output_dim.c == l->output_dim.c && !l->mul) { IElementWiseLayer *lRT = networkRT->addElementWise(*input, *back_tens, ElementWiseOperation::kSUM); checkNULL(lRT); @@ -660,7 +665,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); auto **inputs = new ITensor*[2]; inputs[0] = input; - inputs[1] = back_tens; + inputs[1] = back_tens; auto *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); return lRT; @@ -690,8 +695,9 @@ IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { return lRT; } -IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { - //std::cout<<"convert Upsample\n"; +IResizeLayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { + +#if NV_TENSORRT_MAJOR < 8 auto creator = getPluginRegistry()->getPluginCreator("UpSample_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -705,6 +711,13 @@ IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; +#else + auto *lRT = networkRT->addResize(*input); + lRT->setResizeMode(ResizeMode::kNEAREST); + lRT->setOutputDimensions(Dims3{l->output_dim.c, l->output_dim.h, l->output_dim.w}); + checkNULL(lRT); + return lRT; +#endif } ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { @@ -787,14 +800,14 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { Weights shift{dtRT, mean_b, l->outputs}; Weights scale{dtRT, variance_b, l->outputs}; //std::cout<getNbOutputs()<addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT2 = networkRT->addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, shift, scale, power); - + checkNULL(lRT2); Weights shift2{dtRT, bias_b, l->outputs}; Weights scale2{dtRT, scales_b, l->outputs}; - IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, + IScaleLayer *lRT3 = networkRT->addScale(*lRT2->getOutput(0), ScaleMode::kCHANNEL, shift2, scale2, power); checkNULL(lRT3); -- 2.52.0 From 6837644eb2ea369d4646ba597810755410b724af Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Mon, 3 Jan 2022 18:58:13 +0530 Subject: [PATCH 36/58] add reflection padding from github --- include/tkDNN/kernels.h | 4 +++ src/kernels/padding.cu | 68 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+) create mode 100644 src/kernels/padding.cu diff --git a/include/tkDNN/kernels.h b/include/tkDNN/kernels.h index d809129..a954fe7 100644 --- a/include/tkDNN/kernels.h +++ b/include/tkDNN/kernels.h @@ -48,4 +48,8 @@ void dcnV2CudaForward(cublasStatus_t stat, cublasHandle_t handle, const int dst_dim, cudaStream_t stream = cudaStream_t(0)); void scalAdd(dnnType* dstData, int size, float alpha, float beta, int inc, cudaStream_t stream = cudaStream_t(0)); + +void reflection_pad2d_out_forward(int32_t padding[4], float* srcData, float* dstData, int32_t input_h, int32_t input_w, int32_t plane_dim, int32_t n_batch, cudaStream_t cudaStream = cudaStream_t(0)); + + #endif //KERNELS_H diff --git a/src/kernels/padding.cu b/src/kernels/padding.cu new file mode 100644 index 0000000..731f684 --- /dev/null +++ b/src/kernels/padding.cu @@ -0,0 +1,68 @@ +#include "kernels.h" +#include +#include + + +__device__ +inline thrust::pair get_index_mapping2d( + int32_t input_dim_x,int32_t input_dim_y,int32_t output_dim_x, + int32_t output_dim_y,int32_t pad_l,int32_t pad_t,int32_t output_xy, + int32_t y_shift,int32_t z_shift,int32_t n_plane){ + auto input_offset = ((blockIdx.y + y_shift) + (blockIdx.z + z_shift)*n_plane)*input_dim_x*input_dim_y; + auto output_offset = ((blockIdx.y + y_shift) + (blockIdx.z + z_shift)*n_plane)*output_dim_x*output_dim_y; + auto output_x = output_xy % output_dim_x; + auto output_y = output_xy/output_dim_x; + + auto i_start_x = ::max(int32_t(0),-pad_l); + auto i_start_y = ::max(int32_t(0),-pad_t); + auto o_start_x = ::max(int32_t(0),pad_l); + auto o_start_y = ::max(int32_t(0),pad_t); + + auto input_x = ::abs(output_x - pad_l) - ::abs(output_x - (input_dim_x + pad_l -1)) -output_x + 2*pad_l + input_dim_x -1 -o_start_x + i_start_x; + auto input_y = ::abs(output_y - pad_t) - ::abs(output_y - (input_dim_y + pad_t -1)) -output_y + 2*pad_t + input_dim_y -1 -o_start_y + i_start_y; + + return thrust::make_pair(input_offset + input_y*input_dim_x + input_x,output_offset + output_y*output_dim_x+output_x); +} + +__global__ +void reflection_pad2d_out_kernel( + float* input,float* output,int32_t input_dim_x, + int32_t input_dim_y,int32_t pad_t,int32_t pad_b,int32_t pad_l, + int32_t pad_r,int32_t y_shift,int32_t z_shift,int32_t n_plane){ + auto output_xy = threadIdx.x + blockIdx.x * blockDim.x; + auto output_dim_x = input_dim_x + pad_l + pad_r; + auto output_dim_y = input_dim_y + pad_t + pad_b; + + if(output_xy < output_dim_x*output_dim_y){ + auto index_pair = get_index_mapping2d(input_dim_x,input_dim_y,output_dim_x,output_dim_y,pad_l,pad_t,output_xy,y_shift,z_shift,n_plane); + output[index_pair.second] = input[index_pair.first]; + } +} + +int32_t ceilDiv(int32_t a,int32_t b){ + return (a+b-1)/b; +} + + +void reflection_pad2d_out_forward(int32_t padding[4],float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream){ + int32_t pad_l = padding[0]; + int32_t pad_r = padding[1]; + int32_t pad_t = padding[2]; + int32_t pad_b = padding[3]; + int32_t output_h = input_h + pad_t + pad_b; + int32_t output_w = input_w + pad_l + pad_r; + int32_t size_y = plane_dim; + int32_t size_z = n_batch; + int32_t output_plane_size = output_h*output_w; + dim3 block_size(output_plane_size>256 ?256:output_plane_size); + for(int32_t block_y=0;block_y(65535)); + for(int32_t block_z=0;block_z(65535)); + + dim3 grid_size(ceilDiv(output_plane_size,static_cast(256)),block_y_size,block_z_size); + reflection_pad2d_out_kernel<<>>(srcData,dstData,input_w,input_h,pad_t,pad_b,pad_l,pad_r,block_y,block_z,plane_dim); + } + } + +} -- 2.52.0 From ba022663f15a75be0f820a9b7dcd9a3bdf59142e Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Mon, 3 Jan 2022 19:49:32 +0530 Subject: [PATCH 37/58] completed padding migrations from github --- include/tkDNN/Layer.h | 27 ++++++++++++++++++++++++++- include/tkDNN/NetworkRT.h | 1 + include/tkDNN/kernels.h | 3 +-- src/NetworkRT.cpp | 11 +++++++++++ src/Padding.cpp | 35 +++++++++++++++++++++++++++++++++++ src/kernels/padding.cu | 10 +++++----- 6 files changed, 79 insertions(+), 8 deletions(-) create mode 100644 src/Padding.cpp diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 5273c83..2917733 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -31,7 +31,8 @@ enum layerType_t { LAYER_SHORTCUT, LAYER_UPSAMPLE, LAYER_REGION, - LAYER_YOLO + LAYER_YOLO, + LAYER_PADDING }; #define TKDNN_BN_MIN_EPSILON 1e-5 @@ -87,6 +88,7 @@ public: case LAYER_UPSAMPLE: return "Upsample"; case LAYER_REGION: return "Region"; case LAYER_YOLO: return "Yolo"; + case LAYER_PADDING: return "Padding"; default: return "unknown"; } } @@ -520,9 +522,32 @@ protected: bool poolOn3d; }; +/** + * Padding Layers + * tkDNN supports reflection,constant and zero padding + */ + +typedef enum { + PADDING_MODE_CONSTANT = 0, + PADDING_MODE_ZERO = 1, + PADDING_MODE_REFLECTION = 2 +} tkdnnPaddingMode_t; + +class Padding : public Layer { +public: + Padding(Network *net,int32_t pad_h,int32_t pad_w,tkdnnPaddingMode_t padding_mode); + virtual ~Padding(); + virtual layerType_t getLayerType(){return LAYER_PADDING ;}; + virtual dnnType* infer(dataDim_t& dim,dnnType* srcData); + int32_t paddingH,paddingW; + tkdnnPaddingMode_t padding_mode; + +}; + /** Softmax layer */ + class Softmax : public Layer { public: diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 58a545a..571d127 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -95,6 +95,7 @@ public: nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Yolo *l); nvinfer1::IResizeLayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); + nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input,Padding *l); #if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 bool serialize(const char *filename); diff --git a/include/tkDNN/kernels.h b/include/tkDNN/kernels.h index a954fe7..7c9170f 100644 --- a/include/tkDNN/kernels.h +++ b/include/tkDNN/kernels.h @@ -49,7 +49,6 @@ void dcnV2CudaForward(cublasStatus_t stat, cublasHandle_t handle, void scalAdd(dnnType* dstData, int size, float alpha, float beta, int inc, cudaStream_t stream = cudaStream_t(0)); -void reflection_pad2d_out_forward(int32_t padding[4], float* srcData, float* dstData, int32_t input_h, int32_t input_w, int32_t plane_dim, int32_t n_batch, cudaStream_t cudaStream = cudaStream_t(0)); - +void reflection_pad2d_out_forward(int32_t pad_h,int32_t pad_w,float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream = cudaStream_t(0)); #endif //KERNELS_H diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index ac1f23c..b3aa263 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -275,6 +275,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Layer *l) { return convert_layer(input, (Upsample*) l); if(type == LAYER_DEFORMCONV2D) return convert_layer(input, (DeformConv2d*) l); + if(type == LAYER_PADDING) + return convert_layer(input, (Padding*) l); std::cout<getLayerName()<<"\n"; FatalError("Layer not implemented in tensorRT"); @@ -453,6 +455,15 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { } } +ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ + auto *lRT = networkRT->addSlice(*input,Dims3{0,0,0},Dims3{l->output_dim.c,l->output_dim.h,l->output_dim.w},Dims3{0,0,0}); + if(l->padding_mode == PADDING_MODE_REFLECTION){ + lRT->setMode(SliceMode::kREFLECT); + } + checkNULL(lRT); + return lRT; +} + ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { //std::cout<<"convert Activation\n"; diff --git a/src/Padding.cpp b/src/Padding.cpp new file mode 100644 index 0000000..91857ab --- /dev/null +++ b/src/Padding.cpp @@ -0,0 +1,35 @@ +// +// Created by perseusdg on 03/01/22. +// + +#include +#include "Layer.h" +#include "kernels.h" + +namespace tk{ namespace dnn { + Padding::Padding(Network *net, int32_t pad_h, int32_t pad_w, tkdnnPaddingMode_t padding_mode) : Layer(net) { + this->paddingH = pad_h; + this->paddingW = pad_w; + this->padding_mode = padding_mode; + output_dim.c = input_dim.c; + output_dim.n = input_dim.n; + output_dim.h = input_dim.h + 2 * (this->paddingH); + output_dim.w = input_dim.w + 2 * (this->paddingW); + checkCuda(cudaMalloc(&dstData,output_dim.tot()*sizeof(dnnType))); + } + + Padding::~Padding() { + checkCuda(cudaFree(dstData)); + } + dnnType* Padding::infer(dataDim_t &dim, float *srcData) { + fill(dstData,output_dim.tot(),0.0); + if(padding_mode == tkdnnPaddingMode_t::PADDING_MODE_REFLECTION) + { + reflection_pad2d_out_forward(paddingH, paddingW, srcData, dstData, input_dim.h, input_dim.w, input_dim.c, + input_dim.n); + } + dim = output_dim; + return dstData; + } + +}} diff --git a/src/kernels/padding.cu b/src/kernels/padding.cu index 731f684..1b84ce2 100644 --- a/src/kernels/padding.cu +++ b/src/kernels/padding.cu @@ -44,11 +44,11 @@ int32_t ceilDiv(int32_t a,int32_t b){ } -void reflection_pad2d_out_forward(int32_t padding[4],float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream){ - int32_t pad_l = padding[0]; - int32_t pad_r = padding[1]; - int32_t pad_t = padding[2]; - int32_t pad_b = padding[3]; +void reflection_pad2d_out_forward(int32_t pad_h,int32_t pad_w,float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream){ + int32_t pad_l = pad_w; + int32_t pad_r = pad_w; + int32_t pad_t = pad_h; + int32_t pad_b = pad_w; int32_t output_h = input_h + pad_t + pad_b; int32_t output_w = input_w + pad_l + pad_r; int32_t size_y = plane_dim; -- 2.52.0 From b75cecb105572808cb3c83f3b9ecb076918f09d2 Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Tue, 4 Jan 2022 09:03:04 +0530 Subject: [PATCH 38/58] Added constant and zero padding with ISliceLayer,need to add them for tensorrt versions less than 8.2 using IPluginV2Ext instead of ISliceLayer since they dont seem to support reflect and zero --- include/tkDNN/Layer.h | 3 +- include/tkDNN/kernels.h | 4 + include/tkDNN/pluginsRT/FlattenConcatRT.h | 6 +- include/tkDNN/pluginsRT/ReflectionPadding.h | 99 ++++++++++ src/NetworkRT.cpp | 30 +++ src/Padding.cpp | 12 +- src/kernels/padding.cu | 44 ++++- src/pluginsRT/ReflectionPadding.cpp | 202 ++++++++++++++++++++ 8 files changed, 396 insertions(+), 4 deletions(-) create mode 100644 include/tkDNN/pluginsRT/ReflectionPadding.h create mode 100644 src/pluginsRT/ReflectionPadding.cpp diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 2917733..662eb6a 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -535,12 +535,13 @@ typedef enum { class Padding : public Layer { public: - Padding(Network *net,int32_t pad_h,int32_t pad_w,tkdnnPaddingMode_t padding_mode); + Padding(Network *net,int32_t pad_h,int32_t pad_w,tkdnnPaddingMode_t padding_mode,float constant = 0.0); virtual ~Padding(); virtual layerType_t getLayerType(){return LAYER_PADDING ;}; virtual dnnType* infer(dataDim_t& dim,dnnType* srcData); int32_t paddingH,paddingW; tkdnnPaddingMode_t padding_mode; + float constant; }; diff --git a/include/tkDNN/kernels.h b/include/tkDNN/kernels.h index 7c9170f..4d5474b 100644 --- a/include/tkDNN/kernels.h +++ b/include/tkDNN/kernels.h @@ -51,4 +51,8 @@ void scalAdd(dnnType* dstData, int size, float alpha, float beta, int inc, cudaS void reflection_pad2d_out_forward(int32_t pad_h,int32_t pad_w,float *srcData,float *dstData,int32_t input_h,int32_t input_w,int32_t plane_dim,int32_t n_batch,cudaStream_t cudaStream = cudaStream_t(0)); +void constant_pad2d_forward(dnnType *srcData,dnnType *dstData,int32_t input_h,int32_t input_w,int32_t output_h, + int32_t output_w,int32_t c,int32_t n,int32_t padT,int32_t padL,dnnType constant,cudaStream_t cudaStream = cudaStream_t(0)); + + #endif //KERNELS_H diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 02ff596..f7ec495 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,3 +1,6 @@ +#ifndef _FLATTENCONCATRT_PLUGIN_H +#define _FLATTENCONCATRT_PLUGIN_H + #include #include #include @@ -93,4 +96,5 @@ namespace nvinfer1 { }; REGISTER_TENSORRT_PLUGIN(FlattenConcatRTPluginCreator); -}; \ No newline at end of file +}; +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ReflectionPadding.h b/include/tkDNN/pluginsRT/ReflectionPadding.h new file mode 100644 index 0000000..894ed98 --- /dev/null +++ b/include/tkDNN/pluginsRT/ReflectionPadding.h @@ -0,0 +1,99 @@ +#ifndef _REFLECTIONPADDINGRT_PLUGIN_H +#define _REFLECTIONPADDINGRT_PLUGIN_H + +#include +#include +#include +#include +#include + +namespace nvinfer1{ + class ReflectionPaddingRT : public IPluginV2Ext { + public: + ReflectionPaddingRT(int32_t padH,int32_t padW,int32_t input_h,int32_t input_w,int32_t output_h,int32_t output_w,int32_t c,int32_t n); + + ReflectionPaddingRT(const void *data,size_t length); + + ~ReflectionPaddingRT(); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + + int32_t padH,padW,input_h,input_w,output_h,output_w,n,c; + private: + std::string mPluginNamespace; + + }; + + class ReflectionPaddingRTPluginCreator : public IPluginCreator { + public: + ReflectionPaddingRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; +}; +#endif + diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index b3aa263..6192006 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -456,12 +456,42 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { } ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ + + float rt_ver = float(NV_TENSORRT_MAJOR) + + float(NV_TENSORRT_MINOR)/10 + + float(NV_TENSORRT_PATCH)/100; + +#if ((NV_TENSORRT_MAJOR == 8 && NV_TENSORRT_MINOR >= 2) || NV_TENSORRT_MAJOR > 8) auto *lRT = networkRT->addSlice(*input,Dims3{0,0,0},Dims3{l->output_dim.c,l->output_dim.h,l->output_dim.w},Dims3{0,0,0}); if(l->padding_mode == PADDING_MODE_REFLECTION){ lRT->setMode(SliceMode::kREFLECT); + }else if(l->padding_mode == PADDING_MODE_CONSTANT || l->padding_mode == PADDING_MODE_ZERO){ + lRT->setMode(SliceMode::kFILL); + lRT->setInput(4, reinterpret_cast(l->constant)); } checkNULL(lRT); return lRT; +#else + //todo add PADDING_MODE_CONSTANT AND PADDING_MODE_ZERO for tensorrt versions < 8.2 + if(l->padding_mode == PADDING_MODE_REFLECTION){ + auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + 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; +#endif } ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { diff --git a/src/Padding.cpp b/src/Padding.cpp index 91857ab..1ba6d38 100644 --- a/src/Padding.cpp +++ b/src/Padding.cpp @@ -7,7 +7,7 @@ #include "kernels.h" namespace tk{ namespace dnn { - Padding::Padding(Network *net, int32_t pad_h, int32_t pad_w, tkdnnPaddingMode_t padding_mode) : Layer(net) { + Padding::Padding(Network *net, int32_t pad_h, int32_t pad_w, tkdnnPaddingMode_t padding_mode,float constant) : Layer(net) { this->paddingH = pad_h; this->paddingW = pad_w; this->padding_mode = padding_mode; @@ -15,6 +15,11 @@ namespace tk{ namespace dnn { output_dim.n = input_dim.n; output_dim.h = input_dim.h + 2 * (this->paddingH); output_dim.w = input_dim.w + 2 * (this->paddingW); + if(padding_mode == tkdnnPaddingMode_t::PADDING_MODE_CONSTANT){ + this->constant = constant; + }else{ + this->constant = 0; + } checkCuda(cudaMalloc(&dstData,output_dim.tot()*sizeof(dnnType))); } @@ -28,6 +33,11 @@ namespace tk{ namespace dnn { reflection_pad2d_out_forward(paddingH, paddingW, srcData, dstData, input_dim.h, input_dim.w, input_dim.c, input_dim.n); } + else if(padding_mode == tkdnnPaddingMode_t::PADDING_MODE_CONSTANT){ + constant_pad2d_forward(srcData,dstData,input_dim.h,input_dim.w,output_dim.h,output_dim.w,input_dim.c, + input_dim.n,paddingH,paddingW,constant); + } + dim = output_dim; return dstData; } diff --git a/src/kernels/padding.cu b/src/kernels/padding.cu index 1b84ce2..eafcd5e 100644 --- a/src/kernels/padding.cu +++ b/src/kernels/padding.cu @@ -2,7 +2,9 @@ #include #include - +/* + * Reflection padding is from https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/cuda/ReflectionPad.cu + */ __device__ inline thrust::pair get_index_mapping2d( int32_t input_dim_x,int32_t input_dim_y,int32_t output_dim_x, @@ -66,3 +68,43 @@ void reflection_pad2d_out_forward(int32_t pad_h,int32_t pad_w,float *srcData,flo } } + +/* + * constant padding is inspired from https://github.com/apache/incubator-mxnet/blob/master/src/operator/pad.cu + */ + +__global__ +void constant_pad2d_kernel(dnnType *srcData,dnnType *dstData,const int32_t padT,const int32_t padL,float constant,int32_t n,int32_t c,int32_t i_h,int32_t i_w,int32_t o_h,int32_t o_w){ + int outputPointId = threadIdx.x + blockIdx.x * blockDim.x; + if(outputPointId >= o_h*o_w){ + return ; + } + + int Ny = i_h; + int Nx = i_w; + + int plane = blockIdx.y; + int batch = blockIdx.z; + int outputPointX = outputPointId % o_w; + int outputPointY = outputPointId / o_w; + int checkT = max(0, outputPointY - padT + 1); + int checkB = max(0, padT + Ny - outputPointY); + int checkL = max(0, outputPointX - padL + 1); + int checkR = max(0, padL + Nx - outputPointX); + int inputPointX = min(max(outputPointX - padL, 0), Nx - 1); + int inputPointY = min(max(outputPointY - padT, 0), Ny - 1); + int need_pad = !(checkT * checkB * checkL * checkR); + float value_to_copy = srcData[batch*c*i_h*i_w + plane*i_h*i_w + inputPointY*i_w + inputPointX]; + dstData[batch*c*o_w*o_h + plane*o_h*o_w + outputPointY*o_w + outputPointX] = value_to_copy * (!need_pad) + need_pad*constant; + +} + +void constant_pad2d_forward(dnnType *srcData,dnnType *dstData,int32_t input_h,int32_t input_w,int32_t output_h, + int32_t output_w,int32_t c,int32_t n,int32_t padT,int32_t padL,dnnType constant,cudaStream_t cudaStream){ + int32_t output_plane_size = output_h*output_w; + dim3 block_size(output_plane_size>256 ?256:output_plane_size); + dim3 grid_size(ceilDiv(output_plane_size,static_cast(256)),c,n); + constant_pad2d_kernel<<>>(srcData,dstData,padT,padL,constant,n,c,input_h,input_w,output_h,output_w); + +} + diff --git a/src/pluginsRT/ReflectionPadding.cpp b/src/pluginsRT/ReflectionPadding.cpp new file mode 100644 index 0000000..21d897a --- /dev/null +++ b/src/pluginsRT/ReflectionPadding.cpp @@ -0,0 +1,202 @@ +#include +using namespace nvinfer1; + +std::vector ReflectionPaddingRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReflectionPaddingRTPluginCreator::mFC{}; + +static const char* REFLECTIONPADDINGRT_PLUGIN_VERSION{"1"}; +static const char* REFLECTIONPADDINGRT_PLUGIN_NAME{"ReflectionPaddingRT_tkDNN"}; + +ReflectionPaddingRT::ReflectionPaddingRT(int32_t padH, int32_t padW, int32_t input_h, int32_t input_w, int32_t output_h, + int32_t output_w, int32_t c, int32_t n) { + this->padH = padH; + this->padW = padW; + this->input_h = input_h; + this->input_w = input_w; + this->output_h = output_h; + this->output_w = output_w; + this->n = n; + this->c = c; +} + +ReflectionPaddingRT::ReflectionPaddingRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufcheck=buf; + padH = readBUF(buf); + padW = readBUF(buf); + input_h = readBUF(buf); + input_w = readBUF(buf); + output_h = readBUF(buf); + output_w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + assert(buf = bufcheck + length); +} + +ReflectionPaddingRT::~ReflectionPaddingRT() {} + +int ReflectionPaddingRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ReflectionPaddingRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{c,output_h,output_w}; +} + +int ReflectionPaddingRT::initialize() NOEXCEPT { + return 0; +} + +void ReflectionPaddingRT::terminate() NOEXCEPT { + +} + +size_t ReflectionPaddingRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ReflectionPaddingRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + reflection_pad2d_out_forward(padH,padW,srcData,dstData,input_h,input_w,c,n,stream); + return 0; +} + +#elif NV_TENSORRT_MAJOR <= 7 +int32_t ReflectionPaddingRT::enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream){ + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + reflection_pad2d_out_forward(padH,padW,srcData,dstData,input_h,input_w,c,n,stream); + return 0; +} +#endif + + +size_t ReflectionPaddingRT::getSerializationSize() const NOEXCEPT { + return 8*sizeof(int32_t); +} + +void ReflectionPaddingRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf,padH); + writeBUF(buf,padW); + writeBUF(buf,input_h); + writeBUF(buf,input_w); + writeBUF(buf,output_h); + writeBUF(buf,output_w); + writeBUF(buf,n); + writeBUF(buf,c); +} + +void ReflectionPaddingRT::destroy() NOEXCEPT { + delete this; +} + +const char *ReflectionPaddingRT::getPluginType() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_NAME; +} + +const char *ReflectionPaddingRT::getPluginVersion() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_VERSION; +} + +const char *ReflectionPaddingRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ReflectionPaddingRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ReflectionPaddingRT::clone() const NOEXCEPT { + auto *p = new ReflectionPaddingRT(padH,padW,input_h,input_w,output_h,output_w,c,n); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType +ReflectionPaddingRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ReflectionPaddingRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { +} + +bool ReflectionPaddingRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ReflectionPaddingRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void +ReflectionPaddingRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ReflectionPaddingRT::detachFromContext() NOEXCEPT { + +} + +bool ReflectionPaddingRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + + +ReflectionPaddingRTPluginCreator::ReflectionPaddingRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ReflectionPaddingRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ReflectionPaddingRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ReflectionPaddingRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ReflectionPaddingRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext * +ReflectionPaddingRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int padH = *(static_cast(fields[0].data)); + int padW = *(static_cast(fields[1].data)); + int inputH = *(static_cast(fields[2].data)); + int inputW = *(static_cast(fields[3].data)); + int outputH = *(static_cast(fields[4].data)); + int outputW = *(static_cast(fields[5].data)); + int n = *(static_cast(fields[6].data)); + int c = *(static_cast(fields[7].data)); + auto *pluginObj = new ReflectionPaddingRT(padH,padW,inputH,inputW,outputH,outputW,c,n); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReflectionPaddingRTPluginCreator::getPluginName() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_NAME; +} + +const char *ReflectionPaddingRTPluginCreator::getPluginVersion() const NOEXCEPT { + return REFLECTIONPADDINGRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ReflectionPaddingRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + -- 2.52.0 From 7298dcfb2f4db8c98dbc47a0282d6b99256d8f49 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Thu, 6 Jan 2022 16:30:11 +0000 Subject: [PATCH 39/58] Added monodepth2.cpp --- CMakeLists.txt | 4 + tests/monodepth2/monodepth2.cpp | 275 ++++++++++++++++++++++++++++++++ 2 files changed, 279 insertions(+) create mode 100644 tests/monodepth2/monodepth2.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 7cc9e33..6a775ed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -202,6 +202,10 @@ target_link_libraries(test_shelfnet_berkeley tkDNN) add_executable(test_shelfnet_mapillary tests/shelfnet/shelfnet_mapillary.cpp) target_link_libraries(test_shelfnet_mapillary tkDNN) +# MONODEPTH2 +add_executable(test_monodepth2 tests/monodepth2/monodepth2.cpp) +target_link_libraries(test_monodepth2 tkDNN) + # DEMOS add_executable(test_rtinference tests/test_rtinference/rtinference.cpp) target_link_libraries(test_rtinference tkDNN) diff --git a/tests/monodepth2/monodepth2.cpp b/tests/monodepth2/monodepth2.cpp new file mode 100644 index 0000000..0aa0f2a --- /dev/null +++ b/tests/monodepth2/monodepth2.cpp @@ -0,0 +1,275 @@ +#include +#include +#include +#include +#include + +const char* encoder_conv1_bin = "monodepth2/layers/encoder/encoder-conv1.bin"; +const char* encoder_layer1_bin[] = { + "monodepth2/layers/encoder/encoder-layer1-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer1-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer1-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer1-1-conv2.bin", +}; + +const char* encoder_layer2_bin[] = { + "monodepth2/layers/encoder/encoder-layer2-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer2-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer2-0-downsample-0.bin", + "monodepth2/layers/encoder/encoder-layer2-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer2-1-conv2.bin" +}; + +const char* encoder_layer3_bin[]={ + "monodepth2/layers/encoder/encoder-layer3-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer3-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer3-0-downsample-0.bin", + "monodepth2/layers/encoder/encoder-layer3-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer3-1-conv2.bin" +}; + +const char* encoder_layer4_bin[] = { + "monodepth2/layers/encoder/encoder-layer4-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer4-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer4-0-downsample-0.bin", + "monodepth2/layers/encoder/encoder-layer4-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer4-1-conv2.bin" +}; + +const char *encoder_fc_bin = "monodepth2/layers/encoder/encoder-fc.bin"; + +const char* decoder_layer_bin[] = { + "monodepth2/layers/depth_decoder/decoder-0-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-1-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-2-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-3-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-4-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-5-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-6-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-7-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-8-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-9-conv-conv.bin" +}; + +const char* decoder_dispconv_layer_bin[] = { + "monodepth2/layers/depth_decoder/decoder-10-conv.bin", + "monodepth2/layers/depth_decoder/decoder-11-conv.bin", + "monodepth2/layers/depth_decoder/decoder-12-conv.bin", + "monodepth2/layers/depth_decoder/decoder-13-conv.bin" +}; + +const char* output_bin[] = { + "monodepth2/debug/outputs/output-disp-0.bin", + "monodepth2/debug/outputs/output-disp-1.bin", + "monodepth2/debug/outputs/output-disp-2.bin", + "monodepth2/debug/outputs/output-disp-3.bin" +}; + +const char* input_monodepth2_bin[] = {"monodepth2/debug/input.bin","monodepth2/debug/input2.bin"}; + + +int main(){ + + tk::dnn::dataDim_t dim(1,3,192,640,1); + tk::dnn::Network net(dim); + std::vector features; + new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin, true,false,1, true); + tk::dnn::Layer *encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + features.push_back(encoder_relu_1); + tk::dnn::Layer *last = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); + + //layer 1 + for(int i=0;i<4;i=i+2){ + new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[i], true,false,1, true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[i+1],true,false,1,true); + new tk::dnn::Shortcut(&net,last); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + } + features.push_back(last); + + //layer2 + new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true,false,1,true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer *bn2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true,false,1, true); + new tk::dnn::Route(&net,&last,1); + new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2], true,false,1, true); + new tk::dnn::Shortcut(&net,bn2); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true,false,1, true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true,false,1, true); + new tk::dnn::Shortcut(&net,last); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + features.push_back(last); + + + //layer3 + new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true,false,1, true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + bn2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true,false,1, true); + new tk::dnn::Route(&net,&last,1); + new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2], true,false,1,true); + new tk::dnn::Shortcut(&net,bn2); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true,false,1, true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true,false,1, true); + new tk::dnn::Shortcut(&net,last); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + features.push_back(last); + + + //layer4 + new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true,false,1, true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + bn2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true,false,1, true); + new tk::dnn::Route(&net,&last,1); + new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2], true,false,1, true); + new tk::dnn::Shortcut(&net,bn2); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true,false,1, true); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true,false,1, true); + new tk::dnn::Shortcut(&net,last); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + features.push_back(last); + + std::vector depth_conv_features; + + //decoders + + new tk::dnn::Shortcut(&net,features[4]); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0], false,false,1, false); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer *upsample_layer_1 = new tk::dnn::Upsample(&net, 2); + tk::dnn::Layer *layer_1[2] = {features[3],upsample_layer_1}; + new tk::dnn::Route(&net,layer_1,2); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1], false,false,1,false); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2], false,false,1,false); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer *upsample_layer_2 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer *layer_2[2] = {features[2],upsample_layer_2}; + new tk::dnn::Route(&net,layer_2,2); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3], false,false,1,false); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + depth_conv_features.push_back(last); + + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4],false,false,1,false); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* upsample_layer_3 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer *layer_3[2] = {features[1],upsample_layer_3}; + new tk::dnn::Route(&net,layer_3,2); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5], false,false,1, false); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + depth_conv_features.push_back(last); + + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6], false,false,1, false); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* upsample_layer_4 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer *layer_4[2] = {features[0],upsample_layer_4}; + new tk::dnn::Route(&net,layer_4,2); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7], false,false,1,false); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + depth_conv_features.push_back(last); + + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8], false,false,1,false); + new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + new tk::dnn::Upsample(&net,2); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9], false, false,1, false); + last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + depth_conv_features.push_back(last); + + + new tk::dnn::Route(&net,&depth_conv_features[3],1); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0], false, false,1, false); + tk::dnn::Layer *disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp0->setFinal(); + + new tk::dnn::Route(&net,&depth_conv_features[2],1); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1],false,false,1,false); + tk::dnn::Layer *disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp1->setFinal(); + + + new tk::dnn::Route(&net,&depth_conv_features[1],1); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2], false,false,1, false); + tk::dnn::Layer *disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp2->setFinal(); + + new tk::dnn::Route(&net,&depth_conv_features[0],1); + new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3], false,false,1, false); + tk::dnn::Layer *disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp3->setFinal(); + + + + dnnType *data; + dnnType *input_H; + readBinaryFile(input_monodepth2_bin[1],dim.tot(),&input_H,&data); + std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + for(int i=0;i<4;i++){ + printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); + outs[i]->output_dim.print(); + + dnnType *out, *out_h; + int odim = outs[i]->output_dim.tot(); + readBinaryFile(output_bin[i], odim, &out_h, &out); + + dnnType *cudnn_out, *rt_out; + cudnn_out = outs[i]->dstData; + rt_out = (dnnType *)netRT.buffersRT[i]; + std::cout<<"CUDNN vs correct"; + ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; + std::cout<<"TRT vs correct"; + ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; + std::cout<<"CUDNN vs TRT "; + ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + } + + + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; +} \ No newline at end of file -- 2.52.0 From f189efcbb1e3f8b3522b3e3d8c8844433c5af1e8 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Fri, 7 Jan 2022 05:41:26 +0000 Subject: [PATCH 40/58] Reflection Padding native plugin fix ,forgot to added input_dim.c in the plugin creator --- CMakeLists.txt | 5 +++-- include/tkDNN/pluginsRT/ReflectionPadding.h | 2 ++ src/NetworkRT.cpp | 4 +++- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6a775ed..cadaae7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -85,12 +85,14 @@ endif() find_package(CUDNN REQUIRED) include_directories(${CUDNN_INCLUDE_DIR}) +find_package(yaml-cpp REQUIRED) + # compile file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" "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} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) +target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES} yaml-cpp) @@ -120,7 +122,6 @@ endif() # endif() # gives problems in cross-compiling, probably malformed cmake config -find_package(yaml-cpp REQUIRED) #------------------------------------------------------------------------------- # Build Libraries diff --git a/include/tkDNN/pluginsRT/ReflectionPadding.h b/include/tkDNN/pluginsRT/ReflectionPadding.h index 894ed98..7b13710 100644 --- a/include/tkDNN/pluginsRT/ReflectionPadding.h +++ b/include/tkDNN/pluginsRT/ReflectionPadding.h @@ -94,6 +94,8 @@ namespace nvinfer1{ static std::vector mPluginAttributes; std::string mPluginNamespace; }; + + REGISTER_TENSORRT_PLUGIN(ReflectionPaddingRTPluginCreator); }; #endif diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 6192006..549b010 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -484,13 +484,15 @@ ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); - } auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; + } + #endif } -- 2.52.0 From 3b58fbcb823f161262ddf15ec74d58a498666c90 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Fri, 7 Jan 2022 13:05:09 +0530 Subject: [PATCH 41/58] Added ConstantPadding plugin for TensorRT < 8.2 --- include/tkDNN/NetworkRT.h | 2 + include/tkDNN/pluginsRT/ConstantPaddingRT.h | 109 +++++++++++ src/NetworkRT.cpp | 55 ++++-- src/pluginsRT/ConstantPaddingRT.cpp | 201 ++++++++++++++++++++ 4 files changed, 350 insertions(+), 17 deletions(-) create mode 100644 include/tkDNN/pluginsRT/ConstantPaddingRT.h create mode 100644 src/pluginsRT/ConstantPaddingRT.cpp diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 571d127..b859074 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -23,6 +23,8 @@ #include #include #include +#include +#include diff --git a/include/tkDNN/pluginsRT/ConstantPaddingRT.h b/include/tkDNN/pluginsRT/ConstantPaddingRT.h new file mode 100644 index 0000000..15f4c0d --- /dev/null +++ b/include/tkDNN/pluginsRT/ConstantPaddingRT.h @@ -0,0 +1,109 @@ +// +// Created by perseusdg on 1/7/22. +// + +#ifndef _CONSTANTPADDINGRT_PLUGIN_H +#define _CONSTANTPADDINGRT_PLUGIN_H + +#include +#include +#include +#include +#include + +namespace nvinfer1{ + class ConstantPaddingRT : public IPluginV2Ext { + public: + ConstantPaddingRT(int32_t padH,int32_t padW,int32_t n,int32_t c,int32_t i_h,int32_t i_w,int32_t o_h,int32_t o_w,float constant); + + ConstantPaddingRT(const void *data,size_t length); + + ~ConstantPaddingRT(); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + + int32_t i_h,i_w,o_h,o_w,n,c,padH,padW; + float constant; + private: + std::string mPluginNamespace; + + }; + + class ConstantPaddingRTPluginCreator : public IPluginCreator { + public: + ConstantPaddingRTPluginCreator(); + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + + }; + + REGISTER_TENSORRT_PLUGIN(ConstantPaddingRTPluginCreator); +}; + + +#endif //TKDNN_CONSTANTPADDINGRT_H diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 549b010..3f086bd 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -474,24 +474,45 @@ ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ #else //todo add PADDING_MODE_CONSTANT AND PADDING_MODE_ZERO for tensorrt versions < 8.2 if(l->padding_mode == PADDING_MODE_REFLECTION){ - auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); - std::vector mPluginAttributes; - PluginFieldCollection mFC{}; - mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); - auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); - checkNULL(lRT); - return lRT; + auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); + checkNULL(lRT); + return lRT; + }else if(l->padding_mode == PADDING_MODE_CONSTANT || l->padding_mode == PADDING_MODE_ZERO){ + auto creator = getPluginRegistry()->getPluginCreator("ConstantPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("constant",&l->constant,PluginFieldType::kFLOAT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input,1,*plugin); + checkNULL(lRT); + return lRT; } + + return nullptr; #endif } diff --git a/src/pluginsRT/ConstantPaddingRT.cpp b/src/pluginsRT/ConstantPaddingRT.cpp new file mode 100644 index 0000000..ac37e9d --- /dev/null +++ b/src/pluginsRT/ConstantPaddingRT.cpp @@ -0,0 +1,201 @@ +#include + +using namespace nvinfer1; + +std::vector ConstantPaddingRTPluginCreator::mPluginAttributes; +PluginFieldCollection ConstantPaddingRTPluginCreator::mFC{}; + +static const char* CONSTANTPADDINGRT_PLUGIN_VERSION{"1"}; +static const char* CONSTANTPADDINGRT_PLUGIN_NAME{"ConstantPaddingRT_tkDNN"}; + +ConstantPaddingRT::ConstantPaddingRT(int32_t padH, int32_t padW, int32_t n, int32_t c, int32_t i_h, int32_t i_w, + int32_t o_h, int32_t o_w, float constant) { + this->padH = padH; + this->padW = padW; + this->n = n; + this->c = c; + this->i_h = i_h; + this->i_w = i_w; + this->o_h = o_h; + this->o_w = o_w; + this->constant = constant; + +} + +ConstantPaddingRT::ConstantPaddingRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufcheck=buf; + padH = readBUF(buf); + padW = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + constant = readBUF(buf); + assert(buf = bufcheck + length); +} + +ConstantPaddingRT::~ConstantPaddingRT() {} + +int ConstantPaddingRT::getNbOutputs() const NOEXCEPT{ + return 1; +} + +Dims ConstantPaddingRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{c,o_h,o_w}; +} + +int ConstantPaddingRT::initialize() NOEXCEPT { + return 0; +} + +void ConstantPaddingRT::terminate() NOEXCEPT { + +} + +size_t ConstantPaddingRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ConstantPaddingRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; +} +#endif + +size_t ConstantPaddingRT::getSerializationSize() const NOEXCEPT { + return (8*sizeof(int32_t) + 1*sizeof(float)); +} + +void ConstantPaddingRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf,padH); + writeBUF(buf,padW); + writeBUF(buf,i_h); + writeBUF(buf,i_w); + writeBUF(buf,o_h); + writeBUF(buf,o_w); + writeBUF(buf,n); + writeBUF(buf,c); + writeBUF(buf,constant); +} + +void ConstantPaddingRT::destroy() NOEXCEPT { + delete this; +} + +const char* ConstantPaddingRT::getPluginType() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_NAME; +} + +const char* ConstantPaddingRT::getPluginVersion() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_VERSION; +} + +const char* ConstantPaddingRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ConstantPaddingRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ConstantPaddingRT::clone() const NOEXCEPT { + auto *p = new ConstantPaddingRT(padH,padW,n,c,i_h,i_w,o_h,o_w,constant); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType ConstantPaddingRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, + int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ConstantPaddingRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ConstantPaddingRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ConstantPaddingRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ConstantPaddingRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, + int32_t nbOutputs, const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ConstantPaddingRT::detachFromContext() NOEXCEPT { + +} + +bool ConstantPaddingRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +ConstantPaddingRTPluginCreator::ConstantPaddingRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ConstantPaddingRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ConstantPaddingRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ConstantPaddingRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ConstantPaddingRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ConstantPaddingRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int padH = *(static_cast(fields[0].data)); + int padW = *(static_cast(fields[1].data)); + int inputH = *(static_cast(fields[2].data)); + int inputW = *(static_cast(fields[3].data)); + int outputH = *(static_cast(fields[4].data)); + int outputW = *(static_cast(fields[5].data)); + int n = *(static_cast(fields[6].data)); + int c = *(static_cast(fields[7].data)); + float constant = *(static_cast(fields[8].data)); + auto *pluginObj = new ConstantPaddingRT(padH,padW,n,c,inputH,inputW,outputH,outputW,constant); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ConstantPaddingRTPluginCreator::getPluginName() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_NAME; +} + +const char *ConstantPaddingRTPluginCreator::getPluginVersion() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ConstantPaddingRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} -- 2.52.0 From cabebc95a238d7fcbd27d0bca565b3fedf5bcd4e Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 9 Jan 2022 13:45:44 +0530 Subject: [PATCH 42/58] added individual layer names in monodepth2 --- tests/monodepth2/monodepth2.cpp | 249 +++++++++++++++----------------- 1 file changed, 115 insertions(+), 134 deletions(-) diff --git a/tests/monodepth2/monodepth2.cpp b/tests/monodepth2/monodepth2.cpp index 0aa0f2a..c763baf 100644 --- a/tests/monodepth2/monodepth2.cpp +++ b/tests/monodepth2/monodepth2.cpp @@ -72,156 +72,135 @@ int main(){ tk::dnn::dataDim_t dim(1,3,192,640,1); tk::dnn::Network net(dim); - std::vector features; - new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin, true,false,1, true); - tk::dnn::Layer *encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - features.push_back(encoder_relu_1); - tk::dnn::Layer *last = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); + tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin,true,false,1,true); + tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); - //layer 1 - for(int i=0;i<4;i=i+2){ - new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[i], true,false,1, true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[i+1],true,false,1,true); - new tk::dnn::Shortcut(&net,last); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - } - features.push_back(last); + //layer-1 + tk::dnn::Layer* encoder_layer_1_0_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_0_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); + tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); + tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - //layer2 - new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true,false,1,true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer *bn2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true,false,1, true); - new tk::dnn::Route(&net,&last,1); - new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2], true,false,1, true); - new tk::dnn::Shortcut(&net,bn2); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true,false,1, true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true,false,1, true); - new tk::dnn::Shortcut(&net,last); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - features.push_back(last); + //layer-2 + tk::dnn::Layer* encoder_layer_2_0_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_0_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); + tk::dnn::Layer* encoder_layer_2_0_downsample_convbn = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_convbn_2); + tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); + tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + //layer-3 + tk::dnn::Layer* encoder_layer_3_0_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_0_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); + tk::dnn::Layer* encoder_layer_3_0_downsample_convbn = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_convbn_2); + tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); + tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - //layer3 - new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true,false,1, true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - bn2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true,false,1, true); - new tk::dnn::Route(&net,&last,1); - new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2], true,false,1,true); - new tk::dnn::Shortcut(&net,bn2); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true,false,1, true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true,false,1, true); - new tk::dnn::Shortcut(&net,last); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - features.push_back(last); - - - //layer4 - new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true,false,1, true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - bn2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true,false,1, true); - new tk::dnn::Route(&net,&last,1); - new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2], true,false,1, true); - new tk::dnn::Shortcut(&net,bn2); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true,false,1, true); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true,false,1, true); - new tk::dnn::Shortcut(&net,last); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - features.push_back(last); + //layer-4 + tk::dnn::Layer* encoder_layer_4_0_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_0_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); + tk::dnn::Layer* encoder_layer_4_0_downsample_convbn = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_convbn_2); + tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); + tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - std::vector depth_conv_features; - - //decoders - - new tk::dnn::Shortcut(&net,features[4]); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0], false,false,1, false); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer *upsample_layer_1 = new tk::dnn::Upsample(&net, 2); - tk::dnn::Layer *layer_1[2] = {features[3],upsample_layer_1}; - new tk::dnn::Route(&net,layer_1,2); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1], false,false,1,false); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2], false,false,1,false); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer *upsample_layer_2 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer *layer_2[2] = {features[2],upsample_layer_2}; - new tk::dnn::Route(&net,layer_2,2); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3], false,false,1,false); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - depth_conv_features.push_back(last); - - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4],false,false,1,false); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* upsample_layer_3 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer *layer_3[2] = {features[1],upsample_layer_3}; - new tk::dnn::Route(&net,layer_3,2); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5], false,false,1, false); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - depth_conv_features.push_back(last); - - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6], false,false,1, false); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* upsample_layer_4 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer *layer_4[2] = {features[0],upsample_layer_4}; - new tk::dnn::Route(&net,layer_4,2); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7], false,false,1,false); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - depth_conv_features.push_back(last); - - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8], false,false,1,false); - new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - new tk::dnn::Upsample(&net,2); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9], false, false,1, false); - last = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - depth_conv_features.push_back(last); - - - new tk::dnn::Route(&net,&depth_conv_features[3],1); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0], false, false,1, false); - tk::dnn::Layer *disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + //decoder + tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); + tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; + tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); + tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); + tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); + tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; + tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; + tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); + tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); + tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; + tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); + tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); + tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); + tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; + tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); + tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); + tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); + tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); + tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); + tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); disp0->setFinal(); - new tk::dnn::Route(&net,&depth_conv_features[2],1); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1],false,false,1,false); - tk::dnn::Layer *disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); + tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); + tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); disp1->setFinal(); - - new tk::dnn::Route(&net,&depth_conv_features[1],1); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2], false,false,1, false); - tk::dnn::Layer *disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); + tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); + tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); disp2->setFinal(); - new tk::dnn::Route(&net,&depth_conv_features[0],1); - new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3], false,false,1, false); - tk::dnn::Layer *disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); + tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); + tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); disp3->setFinal(); - dnnType *data; dnnType *input_H; - readBinaryFile(input_monodepth2_bin[1],dim.tot(),&input_H,&data); + readBinaryFile(input_monodepth2_bin[0],dim.tot(),&input_H,&data); std::cout<<"INPUT DIMENSIONS : "< Date: Sun, 9 Jan 2022 19:24:38 +0530 Subject: [PATCH 43/58] depth->tensorrt8 patches --- CMakeLists.txt | 5 +- include/tkDNN/NetworkRT.h | 2 + include/tkDNN/pluginsRT/ReflectionPadding.h | 2 + src/NetworkRT.cpp | 55 +++++++++++++++------ 4 files changed, 46 insertions(+), 18 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7cc9e33..d919b46 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -85,12 +85,14 @@ endif() find_package(CUDNN REQUIRED) include_directories(${CUDNN_INCLUDE_DIR}) +find_package(yaml-cpp REQUIRED) + # compile file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" "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} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) +target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES} yaml-cpp) @@ -120,7 +122,6 @@ endif() # endif() # gives problems in cross-compiling, probably malformed cmake config -find_package(yaml-cpp REQUIRED) #------------------------------------------------------------------------------- # Build Libraries diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 571d127..b859074 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -23,6 +23,8 @@ #include #include #include +#include +#include diff --git a/include/tkDNN/pluginsRT/ReflectionPadding.h b/include/tkDNN/pluginsRT/ReflectionPadding.h index 894ed98..7b13710 100644 --- a/include/tkDNN/pluginsRT/ReflectionPadding.h +++ b/include/tkDNN/pluginsRT/ReflectionPadding.h @@ -94,6 +94,8 @@ namespace nvinfer1{ static std::vector mPluginAttributes; std::string mPluginNamespace; }; + + REGISTER_TENSORRT_PLUGIN(ReflectionPaddingRTPluginCreator); }; #endif diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 6192006..3f086bd 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -474,23 +474,46 @@ ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ #else //todo add PADDING_MODE_CONSTANT AND PADDING_MODE_ZERO for tensorrt versions < 8.2 if(l->padding_mode == PADDING_MODE_REFLECTION){ - auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); - std::vector mPluginAttributes; - PluginFieldCollection mFC{}; - mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); + checkNULL(lRT); + return lRT; + }else if(l->padding_mode == PADDING_MODE_CONSTANT || l->padding_mode == PADDING_MODE_ZERO){ + auto creator = getPluginRegistry()->getPluginCreator("ConstantPaddingRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("padH",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padW",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputH",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("inputW",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputH",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("outputW",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("constant",&l->constant,PluginFieldType::kFLOAT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input,1,*plugin); + checkNULL(lRT); + return lRT; } - auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); - checkNULL(lRT); - return lRT; + + return nullptr; + #endif } -- 2.52.0 From 30239266954c59567c4c72404eabeb0a9b176bb2 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 9 Jan 2022 22:17:43 +0530 Subject: [PATCH 44/58] fix constantpadding commit --- include/tkDNN/pluginsRT/ConstantPaddingRT.h | 109 +++++++++++ src/pluginsRT/ConstantPaddingRT.cpp | 201 ++++++++++++++++++++ 2 files changed, 310 insertions(+) create mode 100644 include/tkDNN/pluginsRT/ConstantPaddingRT.h create mode 100644 src/pluginsRT/ConstantPaddingRT.cpp diff --git a/include/tkDNN/pluginsRT/ConstantPaddingRT.h b/include/tkDNN/pluginsRT/ConstantPaddingRT.h new file mode 100644 index 0000000..15f4c0d --- /dev/null +++ b/include/tkDNN/pluginsRT/ConstantPaddingRT.h @@ -0,0 +1,109 @@ +// +// Created by perseusdg on 1/7/22. +// + +#ifndef _CONSTANTPADDINGRT_PLUGIN_H +#define _CONSTANTPADDINGRT_PLUGIN_H + +#include +#include +#include +#include +#include + +namespace nvinfer1{ + class ConstantPaddingRT : public IPluginV2Ext { + public: + ConstantPaddingRT(int32_t padH,int32_t padW,int32_t n,int32_t c,int32_t i_h,int32_t i_w,int32_t o_h,int32_t o_w,float constant); + + ConstantPaddingRT(const void *data,size_t length); + + ~ConstantPaddingRT(); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; + + int initialize() NOEXCEPT override ; + + void terminate() NOEXCEPT override ; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; + + +#if NV_TENSORRT_MAJOR > 7 + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + + size_t getSerializationSize() const NOEXCEPT override ; + + void serialize(void *buffer) const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginType() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + + int32_t i_h,i_w,o_h,o_w,n,c,padH,padW; + float constant; + private: + std::string mPluginNamespace; + + }; + + class ConstantPaddingRTPluginCreator : public IPluginCreator { + public: + ConstantPaddingRTPluginCreator(); + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + + }; + + REGISTER_TENSORRT_PLUGIN(ConstantPaddingRTPluginCreator); +}; + + +#endif //TKDNN_CONSTANTPADDINGRT_H diff --git a/src/pluginsRT/ConstantPaddingRT.cpp b/src/pluginsRT/ConstantPaddingRT.cpp new file mode 100644 index 0000000..ac37e9d --- /dev/null +++ b/src/pluginsRT/ConstantPaddingRT.cpp @@ -0,0 +1,201 @@ +#include + +using namespace nvinfer1; + +std::vector ConstantPaddingRTPluginCreator::mPluginAttributes; +PluginFieldCollection ConstantPaddingRTPluginCreator::mFC{}; + +static const char* CONSTANTPADDINGRT_PLUGIN_VERSION{"1"}; +static const char* CONSTANTPADDINGRT_PLUGIN_NAME{"ConstantPaddingRT_tkDNN"}; + +ConstantPaddingRT::ConstantPaddingRT(int32_t padH, int32_t padW, int32_t n, int32_t c, int32_t i_h, int32_t i_w, + int32_t o_h, int32_t o_w, float constant) { + this->padH = padH; + this->padW = padW; + this->n = n; + this->c = c; + this->i_h = i_h; + this->i_w = i_w; + this->o_h = o_h; + this->o_w = o_w; + this->constant = constant; + +} + +ConstantPaddingRT::ConstantPaddingRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufcheck=buf; + padH = readBUF(buf); + padW = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + constant = readBUF(buf); + assert(buf = bufcheck + length); +} + +ConstantPaddingRT::~ConstantPaddingRT() {} + +int ConstantPaddingRT::getNbOutputs() const NOEXCEPT{ + return 1; +} + +Dims ConstantPaddingRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{c,o_h,o_w}; +} + +int ConstantPaddingRT::initialize() NOEXCEPT { + return 0; +} + +void ConstantPaddingRT::terminate() NOEXCEPT { + +} + +size_t ConstantPaddingRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +#if NV_TENSORRT_MAJOR > 7 +int ConstantPaddingRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; +} +#elif NV_TENSORRT_MAJOR <= 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; +} +#endif + +size_t ConstantPaddingRT::getSerializationSize() const NOEXCEPT { + return (8*sizeof(int32_t) + 1*sizeof(float)); +} + +void ConstantPaddingRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf,padH); + writeBUF(buf,padW); + writeBUF(buf,i_h); + writeBUF(buf,i_w); + writeBUF(buf,o_h); + writeBUF(buf,o_w); + writeBUF(buf,n); + writeBUF(buf,c); + writeBUF(buf,constant); +} + +void ConstantPaddingRT::destroy() NOEXCEPT { + delete this; +} + +const char* ConstantPaddingRT::getPluginType() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_NAME; +} + +const char* ConstantPaddingRT::getPluginVersion() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_VERSION; +} + +const char* ConstantPaddingRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ConstantPaddingRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2Ext *ConstantPaddingRT::clone() const NOEXCEPT { + auto *p = new ConstantPaddingRT(padH,padW,n,c,i_h,i_w,o_h,o_w,constant); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +DataType ConstantPaddingRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, + int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ConstantPaddingRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ConstantPaddingRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ConstantPaddingRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ConstantPaddingRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, + int32_t nbOutputs, const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ConstantPaddingRT::detachFromContext() NOEXCEPT { + +} + +bool ConstantPaddingRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +ConstantPaddingRTPluginCreator::ConstantPaddingRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ConstantPaddingRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ConstantPaddingRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2Ext *ConstantPaddingRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ConstantPaddingRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2Ext *ConstantPaddingRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int padH = *(static_cast(fields[0].data)); + int padW = *(static_cast(fields[1].data)); + int inputH = *(static_cast(fields[2].data)); + int inputW = *(static_cast(fields[3].data)); + int outputH = *(static_cast(fields[4].data)); + int outputW = *(static_cast(fields[5].data)); + int n = *(static_cast(fields[6].data)); + int c = *(static_cast(fields[7].data)); + float constant = *(static_cast(fields[8].data)); + auto *pluginObj = new ConstantPaddingRT(padH,padW,n,c,inputH,inputW,outputH,outputW,constant); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ConstantPaddingRTPluginCreator::getPluginName() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_NAME; +} + +const char *ConstantPaddingRTPluginCreator::getPluginVersion() const NOEXCEPT { + return CONSTANTPADDINGRT_PLUGIN_VERSION; +} + +const PluginFieldCollection *ConstantPaddingRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} -- 2.52.0 From e1eac2d42ae4d2452b63dbbbf5fbab8904cdcc85 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 9 Jan 2022 23:03:26 +0530 Subject: [PATCH 45/58] Added a seperate layer file for batchnorm,to support an independent batchnorm class in order to pass necessary parameters read from the bin file. --- include/tkDNN/Layer.h | 59 +++++++++++++++++++++++++++++ src/LayerBNWgs.cpp | 88 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 147 insertions(+) create mode 100644 src/LayerBNWgs.cpp diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 662eb6a..28a8817 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -180,6 +180,65 @@ public: }; +class LayerBNWgs : public Layer { +public: + LayerBNWgs(Network* net, int input, int output, std::string fname_weights); + ~LayerBNWgs(); + + int inputs, outputs; + std::string weights_path; + + dnnType* bias_h, * bias_d; + dnnType* power_h = nullptr; + dnnType* scales_h = nullptr, * scales_d = nullptr; + dnnType* mean_h = nullptr, * mean_d = nullptr; + dnnType* variance_h = nullptr, * variance_d = nullptr; + + __half* bias16_h = nullptr, * bias16_d = nullptr; + __half* power16_h = nullptr, * power16_d = nullptr; + __half* scales16_h = nullptr, * scales16_d = nullptr; + __half* mean16_h = nullptr, * mean16_d = nullptr; + __half* variance16_h = nullptr, * variance16_d = nullptr; + + + void releaseHost(bool release32 = true, bool release16 = true) { + if (release32) { + if (bias_h != nullptr) { delete[] bias_h; bias_h = nullptr; } + if (scales_h != nullptr) { delete[] scales_h; scales_h = nullptr; } + if (mean_h != nullptr) { delete[] mean_h; mean_h = nullptr; } + if (variance_h != nullptr) { delete[] variance_h; variance_h = nullptr; } + if (power_h != nullptr) { delete[] power_h; power_h = nullptr; } + } + if (net->fp16 && release16) { + if (bias16_h != nullptr) { delete[] bias16_h; bias16_h = nullptr; } + if (scales16_h != nullptr) { delete[] scales16_h; scales16_h = nullptr; } + if (mean16_h != nullptr) { delete[] mean16_h; mean16_h = nullptr; } + if (variance16_h != nullptr) { delete[] variance16_h; variance16_h = nullptr; } + if (power16_h != nullptr) { delete[] power16_h; power16_h = nullptr; } + + } + } + + void releaseDevice(bool release32 = true, bool release16 = true) { + if (release32) { + if (bias_d != nullptr) { cudaFree(bias_d); bias_d = nullptr; } + if (scales_d != nullptr) { cudaFree(scales_d); scales_d = nullptr; } + if (mean_d != nullptr) { cudaFree(mean_d); mean_d = nullptr; } + if (variance_d != nullptr) { cudaFree(variance_d); variance_d = nullptr; } + } + if (net->fp16 && release16) { + if (bias16_d != nullptr) { cudaFree(bias16_d); bias16_d = nullptr; } + if (scales16_d != nullptr) { cudaFree(scales16_d); scales16_d = nullptr; } + if (mean16_d != nullptr) { cudaFree(mean16_d); mean16_d = nullptr; } + if (variance16_d != nullptr) { cudaFree(variance16_d); variance16_d = nullptr; } + if (power16_d != nullptr) { cudaFree(power16_d); power16_d = nullptr; } + } + } + + + +}; + /** Input layer (it doesn't need weights) */ diff --git a/src/LayerBNWgs.cpp b/src/LayerBNWgs.cpp new file mode 100644 index 0000000..7414ef3 --- /dev/null +++ b/src/LayerBNWgs.cpp @@ -0,0 +1,88 @@ +#include +#include + +#include "Layer.h" +#include "kernels.h" + +namespace tk { namespace dnn { + LayerBNWgs::LayerBNWgs(Network* net, int input, int output, std::string fname_weights) : Layer(net) { + this->inputs = inputs; + this->outputs = output; + this->weights_path = fname_weights; + + std::cout << "Reading BatchNorm O = " << outputs << std::endl; + int seek = 0; + readBinaryFile(weights_path.c_str(), outputs, &bias_h, &bias_d, seek); + seek += outputs; + readBinaryFile(weights_path.c_str(), outputs, &scales_h, &scales_d, seek); + seek += outputs; + readBinaryFile(weights_path.c_str(), outputs, &mean_h, &mean_d, seek); + seek += outputs; + readBinaryFile(weights_path.c_str(), outputs, &variance_h, &variance_d, seek); + seek += outputs; + + float eps = TKDNN_BN_MIN_EPSILON; + + power_h = new dnnType[outputs]; + for (int i = 0; i < outputs; i++) power_h[i] = 1.0f; + + for (int i = 0; i < outputs; i++) + mean_h[i] = mean_h[i] / -sqrt(eps + variance_h[i]); + + for (int i = 0; i < outputs; i++) + variance_h[i] = 1.0f / sqrt(eps + variance_h[i]); + + if (!net->fp16) + return; + + int b_size = outputs; + bias16_h = new __half[b_size]; + cudaMalloc(&bias16_d, b_size * sizeof(__half)); + float2half(bias_d, bias16_d, b_size); + cudaMemcpy(bias16_h, bias16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); + + power16_h = new __half[b_size]; + mean16_h = new __half[b_size]; + variance16_h = new __half[b_size]; + scales16_h = new __half[b_size]; + + cudaMalloc(&power16_d, b_size * sizeof(__half)); + cudaMalloc(&mean16_d, b_size * sizeof(__half)); + cudaMalloc(&variance16_d, b_size * sizeof(__half)); + cudaMalloc(&scales16_d, b_size * sizeof(__half)); + + //temporary buffers + float* tmp_d; + cudaMalloc(&tmp_d, b_size * sizeof(float)); + + //init power array of ones + cudaMemcpy(tmp_d, power_h, b_size * sizeof(float), cudaMemcpyHostToDevice); + float2half(tmp_d, power16_d, b_size); + cudaMemcpy(power16_h, power16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); + + //mean array + cudaMemcpy(tmp_d, mean_h, b_size * sizeof(float), cudaMemcpyHostToDevice); + float2half(tmp_d, mean16_d, b_size); + cudaMemcpy(mean16_h, mean16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); + + //convert variance + + cudaMemcpy(tmp_d, variance_h, b_size * sizeof(float), cudaMemcpyHostToDevice); + float2half(tmp_d, variance16_d, b_size); + cudaMemcpy(variance16_h, variance16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); + + //convert scales + float2half(scales_d, scales16_d, b_size); + cudaMemcpy(scales16_h, scales16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); + + cudaFree(tmp_d); + + + } + + LayerBNWgs::~LayerBNWgs() { + releaseHost(); + releaseDevice(); + } + +} } \ No newline at end of file -- 2.52.0 From bcf0c4eab3d63a2a01ea73b898ee032c98f400c0 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 10 Jan 2022 18:43:12 +0530 Subject: [PATCH 46/58] Added BatchNorm Layer (Testing still needs to be done) --- include/tkDNN/Layer.h | 23 ++++++++++++++- src/BatchNorm.cpp | 67 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 89 insertions(+), 1 deletion(-) create mode 100644 src/BatchNorm.cpp diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 28a8817..62d5a3e 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -32,7 +32,8 @@ enum layerType_t { LAYER_UPSAMPLE, LAYER_REGION, LAYER_YOLO, - LAYER_PADDING + LAYER_PADDING, + LAYER_BATCHNORM }; #define TKDNN_BN_MIN_EPSILON 1e-5 @@ -89,6 +90,7 @@ public: case LAYER_REGION: return "Region"; case LAYER_YOLO: return "Yolo"; case LAYER_PADDING: return "Padding"; + case LAYER_BATCHNORM: return "BatchNorm"; default: return "unknown"; } } @@ -604,6 +606,25 @@ public: }; + +class BatchNorm : public LayerBNWgs { +public: + BatchNorm(Network *net,int output,std::string fname_weights); + virtual ~BatchNorm(); + virtual layerType_t getLayerType(){return LAYER_BATCHNORM;}; + virtual dnnType* infer(dataDim_t& dim,dnnType* srcData); + std::string weights_bin; +protected: + cudnnFilterDescriptor_t filterDesc; + cudnnConvolutionFwdAlgoPerf_t algo; + cudnnConvolutionBwdDataAlgoPerf_t bwAlgo; + cudnnTensorDescriptor_t biasTensorDesc; + + void initCUDNN(); + void inferCUDNN(dnnType* srcData); + void* workSpace; + size_t ws_sizeInBytes; +}; /** Softmax layer */ diff --git a/src/BatchNorm.cpp b/src/BatchNorm.cpp new file mode 100644 index 0000000..b406011 --- /dev/null +++ b/src/BatchNorm.cpp @@ -0,0 +1,67 @@ +#include + +#include "Layer.h" + +namespace tk { namespace dnn { + void BatchNorm::initCUDNN(){ + cudnnTensorDescriptor_t srcTensor = srcTensorDesc; + cudnnTensorDescriptor_t dstTensor = dstTensorDesc; + dataDim_t idim,odim; + idim = input_dim; + odim = output_dim; + + checkCUDNN( cudnnSetTensor4dDescriptor(srcTensor, + net->tensorFormat, net->dataType, idim.n, idim.c, idim.h, idim.w) ); + + checkCUDNN( cudnnCreateTensorDescriptor(&biasTensorDesc) ); + + checkCUDNN( cudnnSetTensor4dDescriptor(dstTensor, + net->tensorFormat, net->dataType, odim.n, odim.c, odim.h, odim.w) ); + + checkCUDNN( cudnnSetTensor4dDescriptor(biasTensorDesc, + net->tensorFormat, net->dataType, + 1, output_dim.c, 1, 1) ); + + + } + + void BatchNorm::inferCUDNN(float *srcData){ + dnnType alpha = dnnType(1); + dnnType beta = dnnType(0); + + alpha = dnnType(1); + beta = dnnType(1); + checkCUDNN( cudnnAddTensor(net->cudnnHandle, + &alpha, biasTensorDesc, bias_d, + &beta, dstTensorDesc, dstData) ); + alpha = dnnType(1); + beta = dnnType(0); + checkCUDNN( cudnnBatchNormalizationForwardInference(net->cudnnHandle, + CUDNN_BATCHNORM_SPATIAL, &alpha, &beta, + dstTensorDesc, dstData, dstTensorDesc, + dstData, biasTensorDesc, //same tensor descriptor as bias + scales_d, bias_d, mean_d, variance_d, + TKDNN_BN_MIN_EPSILON) ); + } + + BatchNorm::BatchNorm(Network *net,int output,std::string fname_weights) : + LayerBNWgs(net,net->getOutputDim().c,output,fname_weights){ + output_dim = input_dim; + initCUDNN(); + checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); + + } + + dnnType* BatchNorm::infer(dataDim_t &dim,dnnType* srcData){ + inferCUDNN(srcData); + + dim = output_dim; + return dstData; + } + + BatchNorm::~BatchNorm(){ + checkCUDNN( cudnnDestroyTensorDescriptor(biasTensorDesc) ); + checkCuda( cudaFree(dstData) ); + } + +}} \ No newline at end of file -- 2.52.0 From 061bc79a69e8aa4960c12bd137169269c0fc8779 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 10 Jan 2022 22:40:31 +0530 Subject: [PATCH 47/58] Added BatchNorm to NetworkRT (conver_layer) --- include/tkDNN/NetworkRT.h | 1 + src/NetworkRT.cpp | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index b859074..10394bc 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -98,6 +98,7 @@ public: nvinfer1::IResizeLayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input,Padding *l); + nvinfer1::ILayer* convert_layer(nvinfer1::ITensor* input,BatchNorm *l); #if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 bool serialize(const char *filename); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 3f086bd..b83de23 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -277,6 +277,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Layer *l) { return convert_layer(input, (DeformConv2d*) l); if(type == LAYER_PADDING) return convert_layer(input, (Padding*) l); + if(type == LAYER_BATCHNORM) + return convert_layer(input,(BatchNorm*) l); std::cout<getLayerName()<<"\n"; FatalError("Layer not implemented in tensorRT"); @@ -407,6 +409,38 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { return lRT; } +ILayer* NetworkRT::convert_layer(ITensor *input,BatchNorm *l){ + void *bias_b, *power_b, *mean_b, *variance_b, *scales_b; + if(dtRT == DataType::kHALF) { + bias_b = l->bias16_h; + power_b = l->power16_h; + mean_b = l->mean16_h; + variance_b = l->variance16_h; + scales_b = l->scales16_h; + } else { + bias_b = l->bias_h; + power_b = l->power_h; + mean_b = l->mean_h; + variance_b = l->variance_h; + scales_b = l->scales_h; + } + Weights power{dtRT, power_b, l->outputs}; + Weights shift{dtRT, mean_b, l->outputs}; + Weights scale{dtRT, variance_b, l->outputs}; + + IScaleLayer *lRT = networkRT->addScale(*input, ScaleMode::kCHANNEL, + shift, scale, power); + checkNULL(lRT); + Weights shift2{dtRT, bias_b, l->outputs}; + Weights scale2{dtRT, scales_b, l->outputs}; + IScaleLayer *lRT2 = networkRT->addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, + shift2, scale2, power); + checkNULL(lRT2); + + return lRT2; + +} + ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { // std::cout<<"convert Pooling\n"; -- 2.52.0 From 19e41a8b992a005cb019f6061291e47e97900b36 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 11 Jan 2022 12:38:36 +0530 Subject: [PATCH 48/58] monodepth2 new format (test) conv + independent batch norm --- CMakeLists.txt | 3 + tests/monodepth2/monodepth2_new_format.cpp | 306 +++++++++++++++++++++ 2 files changed, 309 insertions(+) create mode 100644 tests/monodepth2/monodepth2_new_format.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index cadaae7..8a6d616 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -207,6 +207,9 @@ target_link_libraries(test_shelfnet_mapillary tkDNN) add_executable(test_monodepth2 tests/monodepth2/monodepth2.cpp) target_link_libraries(test_monodepth2 tkDNN) +add_executable(test_monodepth2_new_format tests/monodepth2/monodepth2_new_format.cpp) +target_link_libraries(test_monodepth2_new_format tkDNN) + # DEMOS add_executable(test_rtinference tests/test_rtinference/rtinference.cpp) target_link_libraries(test_rtinference tkDNN) diff --git a/tests/monodepth2/monodepth2_new_format.cpp b/tests/monodepth2/monodepth2_new_format.cpp new file mode 100644 index 0000000..313978c --- /dev/null +++ b/tests/monodepth2/monodepth2_new_format.cpp @@ -0,0 +1,306 @@ +#include +#include +#include +#include +#include + +const char* encoder_conv1_bin = "monodepth2/layers/encoder/encoder-conv1.bin"; +const char* encoder_bn1_bin = "monodepth2/layers/encoder/encoder-bn1.bin"; + +const char* encoder_layer1_conv_bin[] = { + "monodepth2/layers/encoder/encoder-layer1-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer1-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer1-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer1-1-conv2.bin", +}; + +const char* encoder_layer1_bn_bin[] = { + "monodepth2/layers/encoder/encoder-layer1-0-bn1.bin", + "monodepth2/layers/encoder/encoder-layer1-0-bn2.bin", + "monodepth2/layers/encoder/encoder-layer1-1-bn1.bin", + "monodepth2/layers/encoder/encoder-layer1-1-bn2.bin", +}; + + + +const char* encoder_layer2_conv_bin[] = { + "monodepth2/layers/encoder/encoder-layer2-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer2-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer2-0-downsample-0.bin", + "monodepth2/layers/encoder/encoder-layer2-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer2-1-conv2.bin" +}; + +const char* encoder_layer2_bn_bin[] = { + "monodepth2/layers/encoder/encoder-layer2-0-bn1.bin", + "monodepth2/layers/encoder/encoder-layer2-0-bn2.bin", + "monodepth2/layers/encoder/encoder-layer2-0-downsample-1.bin", + "monodepth2/layers/encoder/encoder-layer2-1-bn1.bin", + "monodepth2/layers/encoder/encoder-layer2-1-bn2.bin" +}; + +const char* encoder_layer3_conv_bin[]={ + "monodepth2/layers/encoder/encoder-layer3-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer3-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer3-0-downsample-0.bin", + "monodepth2/layers/encoder/encoder-layer3-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer3-1-conv2.bin" +}; + +const char* encoder_layer3_bn_bin[]={ + "monodepth2/layers/encoder/encoder-layer3-0-bn1.bin", + "monodepth2/layers/encoder/encoder-layer3-0-bn2.bin", + "monodepth2/layers/encoder/encoder-layer3-0-downsample-1.bin", + "monodepth2/layers/encoder/encoder-layer3-1-bn1.bin", + "monodepth2/layers/encoder/encoder-layer3-1-bn2.bin" +}; + +const char* encoder_layer4_conv_bin[] = { + "monodepth2/layers/encoder/encoder-layer4-0-conv1.bin", + "monodepth2/layers/encoder/encoder-layer4-0-conv2.bin", + "monodepth2/layers/encoder/encoder-layer4-0-downsample-0.bin", + "monodepth2/layers/encoder/encoder-layer4-1-conv1.bin", + "monodepth2/layers/encoder/encoder-layer4-1-conv2.bin" +}; + +const char* encoder_layer4_bn_bin[] = { + "monodepth2/layers/encoder/encoder-layer4-0-bn1.bin", + "monodepth2/layers/encoder/encoder-layer4-0-bn2.bin", + "monodepth2/layers/encoder/encoder-layer4-0-downsample-1.bin", + "monodepth2/layers/encoder/encoder-layer4-1-bn1.bin", + "monodepth2/layers/encoder/encoder-layer4-1-bn2.bin" +}; + +const char* decoder_layer_bin[] = { + "monodepth2/layers/depth_decoder/decoder-0-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-1-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-2-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-3-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-4-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-5-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-6-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-7-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-8-conv-conv.bin", + "monodepth2/layers/depth_decoder/decoder-9-conv-conv.bin" +}; + +const char* decoder_dispconv_layer_bin[] = { + "monodepth2/layers/depth_decoder/decoder-10-conv.bin", + "monodepth2/layers/depth_decoder/decoder-11-conv.bin", + "monodepth2/layers/depth_decoder/decoder-12-conv.bin", + "monodepth2/layers/depth_decoder/decoder-13-conv.bin" +}; + +const char* output_bin[] = { + "monodepth2/debug/outputs/output-disp-0.bin", + "monodepth2/debug/outputs/output-disp-1.bin", + "monodepth2/debug/outputs/output-disp-2.bin", + "monodepth2/debug/outputs/output-disp-3.bin" +}; + +const char* input_monodepth2_bin[] = {"monodepth2/debug/input.bin","monodepth2/debug/input2.bin"}; + +int main(){ + tk::dnn::dataDim_t dim(1,3,192,640,1); + tk::dnn::Network net(dim); + tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin); + tk::dnn::Layer* encoder_bn = new tk::dnn::BatchNorm(&net,64,encoder_bn1_bin); + tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); + + //layer-1 + tk::dnn::Layer* encoder_layer_1_0_conv_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[0]); + tk::dnn::Layer* encoder_layer_1_0_bn_1 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[0]); + tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_0_conv_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[1]); + tk::dnn::Layer* encoder_layer_1_0_bn_2 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[1]); + tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); + tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_conv_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[2]); + tk::dnn::Layer* encoder_layer_1_1_bn_1 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[2]); + tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_conv_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[3]); + tk::dnn::Layer* encoder_layer_1_1_bn_2 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[3]); + tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); + tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-2 + tk::dnn::Layer* encoder_layer_2_0_conv_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_conv_bin[0]); + tk::dnn::Layer* encoder_layer_2_0_bn_1 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[0]); + tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_0_conv_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[1]); + tk::dnn::Layer* encoder_layer_2_0_bn_2 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[1]); + tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); + tk::dnn::Layer* encoder_layer_2_0_downsample_conv = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_conv_bin[2]); + tk::dnn::Layer* encoder_layer_2_0_downsample_bn = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[2]); + tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_downsample_bn); + tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_conv_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[3]); + tk::dnn::Layer* encoder_layer_2_1_bn_1 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[3]); + tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_conv_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[4]); + tk::dnn::Layer* encoder_layer_2_1_bn_2 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[4]); + tk::dnn::Layer* encoder_layer_2_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); + tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-3 + tk::dnn::Layer* encoder_layer_3_0_conv_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_conv_bin[0]); + tk::dnn::Layer* encoder_layer_3_0_bn_1 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[0]); + tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_0_conv_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[1]); + tk::dnn::Layer* encoder_layer_3_0_bn_2 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[1]); + tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); + tk::dnn::Layer* encoder_layer_3_0_downsample_conv = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_conv_bin[2]); + tk::dnn::Layer* encoder_layer_3_0_downsample_bn = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[2]); + tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_bn_2); + tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_conv_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[3]); + tk::dnn::Layer* encoder_layer_3_1_bn_1 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[3]); + tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_conv_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[4]); + tk::dnn::Layer* encoder_layer_3_1_bn_2 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[4]); + tk::dnn::Layer* encoder_layer_3_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); + tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-4 + tk::dnn::Layer* encoder_layer_4_0_conv_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_conv_bin[0]); + tk::dnn::Layer* encoder_layer_4_0_bn_1 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[0]); + tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_0_conv_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[1]); + tk::dnn::Layer* encoder_layer_4_0_bn_2 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[1]); + tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); + tk::dnn::Layer* encoder_layer_4_0_downsample_conv = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_conv_bin[2]); + tk::dnn::Layer* encoder_layer_4_0_downsample_bn = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[2]); + tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_bn_2); + tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_conv_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[3]); + tk::dnn::Layer* encoder_layer_4_1_bn_1 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[3]); + tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_conv_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[4]); + tk::dnn::Layer* encoder_layer_4_1_bn_2 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[4]); + tk::dnn::Layer* encoder_layer_4_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); + tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + + //decoder + tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); + tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; + tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); + tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); + tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); + tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; + tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; + tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); + tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); + tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; + tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); + tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); + tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); + tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; + tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); + tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); + tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); + tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); + tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); + tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp0->setFinal(); + + tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); + tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); + tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp1->setFinal(); + + tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); + tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); + tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp2->setFinal(); + + tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); + tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); + tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp3->setFinal(); + + dnnType *data; + dnnType *input_H; + readBinaryFile(input_monodepth2_bin[1],dim.tot(),&input_H,&data); + std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + for(int i=0;i<4;i++){ + printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); + outs[i]->output_dim.print(); + + dnnType *out, *out_h; + int odim = outs[i]->output_dim.tot(); + readBinaryFile(output_bin[i], odim, &out_h, &out); + + dnnType *cudnn_out, *rt_out; + cudnn_out = outs[i]->dstData; + rt_out = (dnnType *)netRT.buffersRT[i]; + std::cout<<"CUDNN vs correct"; + ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; + std::cout<<"TRT vs correct"; + ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; + std::cout<<"CUDNN vs TRT "; + ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + } + + + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; + +} \ No newline at end of file -- 2.52.0 From 907df27e07ce2da961ec6729983f144f305619e1 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Tue, 18 Jan 2022 21:34:16 -0800 Subject: [PATCH 49/58] Fix monodepth2, add demoDepth: - Fix monodepth2 network, now works with both cuDNN and tensorRT - Substitute cuDNN ELU with tkDNN one - add DepthNN class - add demoDepth demo, now only works with monodepth2 net Signed-off-by: Micaela Verucchi Francesco Gatti --- CMakeLists.txt | 3 + demo/demo/demoDepth.cpp | 103 +++++++++++++++++++ include/tkDNN/DepthNN.h | 174 ++++++++++++++++++++++++++++++++ include/tkDNN/Layer.h | 1 - include/tkDNN/NetworkRT.h | 1 + include/tkDNN/NetworkViz.h | 2 +- src/Activation.cpp | 3 + src/NetworkRT.cpp | 76 ++++++++++++++ src/NetworkViz.cpp | 2 +- tests/monodepth2/monodepth2.cpp | 70 +++++++------ 10 files changed, 401 insertions(+), 34 deletions(-) create mode 100644 demo/demo/demoDepth.cpp create mode 100644 include/tkDNN/DepthNN.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 8a6d616..a109c36 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -229,6 +229,9 @@ target_link_libraries(demoTracker tkDNN) add_executable(seg_demo demo/demo/seg_demo.cpp) target_link_libraries(seg_demo tkDNN) +add_executable(demoDepth demo/demo/demoDepth.cpp) +target_link_libraries(demoDepth tkDNN) + #------------------------------------------------------------------------------- # Install #------------------------------------------------------------------------------- diff --git a/demo/demo/demoDepth.cpp b/demo/demo/demoDepth.cpp new file mode 100644 index 0000000..eda04c6 --- /dev/null +++ b/demo/demo/demoDepth.cpp @@ -0,0 +1,103 @@ +#include +#include +#include /* srand, rand */ +//#include +#include + +#include "tkDNN/DepthNN.h" + +bool gRun; + +void sig_handler(int signo) { + std::cout<<"request gateway stop\n"; + gRun = false; +} + +int main(int argc, char *argv[]) { + + signal(SIGINT, sig_handler); + + std::string net = "monodepth2_fp32.rt"; + if(argc > 1) + net = argv[1]; + #ifdef __linux__ + std::string input = "../demo/yolo_test.mp4"; + #elif _WIN32 + std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; + #endif + if(argc > 2) + input = argv[2]; + bool show = true; + if(argc > 3) + show = atoi(argv[3]); + bool save = true; + if(argc > 4) + save = atoi(argv[4]); + + std::cout <<"Net settings - net: "<< net + <<"\n"; + std::cout <<"Demo settings - input: "<< input + <<", show: "<< show + <<", save: "<< save<<"\n\n"; + + tk::dnn::DepthNN depthNN; + + // create depth network + int n_batch = 1; + depthNN.init(net, n_batch); + + // open video stream + cv::VideoCapture cap(input); + if(!cap.isOpened()) + gRun = false; + else + std::cout<<"camera started\n"; + + cv::VideoWriter resultVideo; + if(save) { + int w = 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)); + } + + if(show) + cv::namedWindow("depth", cv::WINDOW_NORMAL); + + cv::Mat frame; + std::vector batch_frame; + std::vector batch_dnn_input; + + // start detection loop + gRun = true; + while(gRun) { + batch_dnn_input.clear(); + batch_frame.clear(); + + //read frame + cap >> frame; + if(!frame.data) + break; + batch_frame.push_back(frame); + batch_dnn_input.push_back(frame.clone()); + + //inference + depthNN.update(batch_dnn_input, 1); + if(show){ + cv::imshow("depth", depthNN.depthMats[0]); + cv::waitKey(1); + + } + } + + std::cout<<"detection end\n"; + + double mean = 0; + std::cout< +#include +#include +#ifdef __linux__ +#include +#endif + +#include + +#include +#include +#include + +#include "tkDNN/utils.h" +#include "tkDNN/tkdnn.h" + +#include "NetworkViz.h" + + +namespace tk { namespace dnn { + +class DepthNN { + + public: + tk::dnn::NetworkRT *netRT = nullptr; + dnnType *input_h; + dnnType *input_d; + float* depth_h; + + int nBatches = 1; + + cv::Mat bgr[3]; + cv::Mat imagePreproc; + + std::vector stats; /*keeps track of inference times (ms)*/ + std::vector> depths; + std::vector depthMats; + + DepthNN() {}; + ~DepthNN(){}; + + /** + * Method used to initialize the class, allocate memory and compute + * needed data. + * + * @param tensor_path path to the rt file of the NN. + * @param n_batches maximum number of batches to use in inference + * @return true if everything is correct, false otherwise. + */ + void init(const std::string& tensor_path, const int n_batches=1){ + //create net + + std::cout<<(tensor_path).c_str()<<"\n"; + nBatches = n_batches; + netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str()); + + //allocate memory for NN input + checkCuda(cudaMallocHost(&input_h, sizeof(dnnType) * netRT->input_dim.tot() * nBatches)); + checkCuda(cudaMalloc(&input_d, sizeof(dnnType) * netRT->input_dim.tot() * nBatches)); + + //allocate memory for NN output + depthMats.resize(nBatches); + depths.resize(nBatches); + for(int i=0; i< depths.size();++i) + depths[i].resize(netRT->buffersDIM[1].tot()); + + depth_h = (float *)malloc(netRT->buffersDIM[1].tot() * sizeof(float)); + + } + + + /** + * This method preprocess the image, before feeding it to the NN. + * + * @param frame original frame to adapt for inference. + * @param bi batch index + */ + void preprocess(cv::Mat &frame, const int bi=0) { + //resize image, remove mean, divide by std + cv::Mat frame_nomean; + resize(frame, frame, cv::Size(netRT->input_dim.w, netRT->input_dim.h)); + frame.convertTo(frame_nomean, CV_32FC3); + frame_nomean.convertTo(imagePreproc, CV_32FC3, 1 / 255.0, 0); + + //copy image into tensor and copy it into GPU + cv::split(imagePreproc, bgr); + for (int i = 0; i < netRT->input_dim.c; i++){ + int idx = i * imagePreproc.rows * imagePreproc.cols; + int ch = netRT->input_dim.c-1 -i; + memcpy((void *)&input_h[idx + netRT->input_dim.tot()*bi], (void *)bgr[ch].data, imagePreproc.rows * imagePreproc.cols * sizeof(dnnType)); + } + checkCuda(cudaMemcpyAsync(input_d+ netRT->input_dim.tot()*bi, input_h + netRT->input_dim.tot()*bi, netRT->input_dim.tot() * sizeof(dnnType), cudaMemcpyHostToDevice, netRT->stream)); + } + + /** + * This method postprocess the output of the NN to obtain the correct + * boundig boxes. + * + * @param bi batch index + * @param mAP set to true only if all the probabilities for a bounding + * box are needed, as in some cases for the mAP calculation + */ + void postprocess(const int bi=0) { + + dnnType *rt_out[1]; + rt_out[0] = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[1].tot()*bi; + checkCuda(cudaMemcpy(depth_h, rt_out[0], netRT->buffersDIM[1].tot()* sizeof(float), cudaMemcpyDeviceToHost)); + memcpy(&depths[bi][0], &depth_h[0], netRT->buffersDIM[1].tot()* sizeof(float)); + + // cv::Mat d(netRT->buffersDIM[1].h, netRT->buffersDIM[1].w, CV_8UC1, depth_h); + // depthMats[bi] = d.clone(); + + cv::Mat depth_mat = vizData2Mat(rt_out[0], netRT->buffersDIM[1], netRT->buffersDIM[1].h, netRT->buffersDIM[1].w); + // cv::Mat depth_mat = vizData2Mat((dnnType *)netRT->buffersRT[0], netRT->buffersDIM[0], netRT->buffersDIM[0].h, netRT->buffersDIM[0].w); + depthMats[bi] = depth_mat.clone(); + + } + + /** + * This method performs the inference of the NN. + * + * @param frames frames to build the embedding from. + * @param cur_batches number of batches to use in inference + */ + void update(std::vector& frames, const int cur_batches=1){ + if(cur_batches > nBatches) + FatalError("A batch size greater than nBatches cannot be used"); + + if(TKDNN_VERBOSE) printCenteredTitle(" TENSORRT feature extraction ", '=', 30); + { + TKDNN_TSTART + for(int bi=0; biinput_dim; + dim.n = cur_batches; + { + if(TKDNN_VERBOSE) dim.print(); + TKDNN_TSTART + netRT->infer(dim, input_d); + TKDNN_TSTOP + if(TKDNN_VERBOSE) dim.print(); + stats.push_back(t_ns); + } + + { + TKDNN_TSTART + for(int bi=0; bi 5 && NV_TENSORRT_MAJOR < 8 bool serialize(const char *filename); diff --git a/include/tkDNN/NetworkViz.h b/include/tkDNN/NetworkViz.h index 2cf8009..ffdf361 100644 --- a/include/tkDNN/NetworkViz.h +++ b/include/tkDNN/NetworkViz.h @@ -6,7 +6,7 @@ namespace tk { namespace dnn { cv::Mat vizFloat2colorMap(cv::Mat map, double min=0, double max=0, int classes=19); -cv::Mat vizData2Mat(dnnType *dataInput, tk::dnn::dataDim_t dim, int img_h, int img_w, double min=0, double max=0, int classes=19); +cv::Mat vizData2Mat(dnnType *dataInput, tk::dnn::dataDim_t dim, int img_h, int img_w, double min=0, double max=0, int classes=0); cv::Mat vizLayer2Mat(tk::dnn::Network *net, int layer, int imgdim = 1000); }} diff --git a/src/Activation.cpp b/src/Activation.cpp index 0b113a7..947b019 100644 --- a/src/Activation.cpp +++ b/src/Activation.cpp @@ -56,6 +56,9 @@ dnnType* Activation::infer(dataDim_t &dim, dnnType* srcData) { else if(act_mode == ACTIVATION_LOGISTIC) { activationLOGISTICForward(srcData, dstData, dim.tot()); + } else if(act_mode == ACTIVATION_ELU) { + activationELUForward(srcData, dstData, dim.tot()); + } else { dnnType alpha = dnnType(1); dnnType beta = dnnType(0); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index b83de23..9b5f14c 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -279,6 +279,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Layer *l) { return convert_layer(input, (Padding*) l); if(type == LAYER_BATCHNORM) return convert_layer(input,(BatchNorm*) l); + if(type == LAYER_MULADD) + return convert_layer(input,(MulAdd*) l); std::cout<getLayerName()<<"\n"; FatalError("Layer not implemented in tensorRT"); @@ -441,6 +443,80 @@ ILayer* NetworkRT::convert_layer(ITensor *input,BatchNorm *l){ } +ILayer* NetworkRT::convert_layer(ITensor *input,MulAdd *l){ + + void *power_b, *shift_b, *scales_b; + int size = l->input_dim.tot(); + + power_b = new dnnType[size]; + shift_b = new dnnType[size]; + scales_b = new dnnType[size]; + + for(int i=0; iadd; + ((dnnType*) scales_b)[i] = l->mul; + } + + if(dtRT == DataType::kHALF) { + + __half *power16_h = nullptr, *power16_d = nullptr; + __half *scales16_h = nullptr, *scales16_d = nullptr; + __half *shift16_h = nullptr, *shift16_d = nullptr; + + dnnType * power_d = nullptr; + dnnType * scales_d = nullptr; + dnnType * shift_d = nullptr; + + cudaMalloc(&power_d, size*sizeof(dnnType)); + cudaMemcpy(power_d, power_b, size*sizeof(dnnType), cudaMemcpyHostToDevice); + + cudaMalloc(&shift_d, size*sizeof(dnnType)); + cudaMemcpy(shift_d, shift_b, size*sizeof(dnnType), cudaMemcpyHostToDevice); + + cudaMalloc(&scales_d, size*sizeof(dnnType)); + cudaMemcpy(scales_d, scales_b, size*sizeof(dnnType), cudaMemcpyHostToDevice); + + //convert to fp16 + power16_h = new __half[size]; + cudaMalloc(&power16_d, size*sizeof(__half)); + float2half(power_d, power16_d, size); + cudaMemcpy(power16_h, power16_d, size*sizeof(__half), cudaMemcpyDeviceToHost); + + shift16_h = new __half[size]; + cudaMalloc(&shift16_d, size*sizeof(__half)); + float2half(shift_d, shift16_d, size); + cudaMemcpy(shift16_h, shift16_d, size*sizeof(__half), cudaMemcpyDeviceToHost); + + scales16_h = new __half[size]; + cudaMalloc(&scales16_d, size*sizeof(__half)); + float2half(scales_d, scales16_d, size); + cudaMemcpy(scales16_h, scales16_d, size*sizeof(__half), cudaMemcpyDeviceToHost); + + power_b = power16_h; + shift_b = shift16_h; + scales_b = scales16_h; + + + cudaFree(power16_d); + cudaFree(shift16_d); + cudaFree(scales16_d); + + cudaFree(power_d); + cudaFree(shift_d); + cudaFree(scales_d); + } + + Weights power{dtRT, power_b, size}; + Weights shift{dtRT, shift_b, size}; + Weights scale{dtRT, scales_b, size}; + IScaleLayer *lRT = networkRT->addScale(*input, ScaleMode::kELEMENTWISE, + shift, scale, power); + checkNULL(lRT); + return lRT; +} + + ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { // std::cout<<"convert Pooling\n"; diff --git a/src/NetworkViz.cpp b/src/NetworkViz.cpp index b6c95d9..8dbb20e 100644 --- a/src/NetworkViz.cpp +++ b/src/NetworkViz.cpp @@ -383,7 +383,7 @@ cv::Mat vizFloat2colorMap(cv::Mat map,double min, double max, int classes) { default: // expand your range to 0..255. Similar to histEq(); map.convertTo(adjMap,CV_8UC1, 255 / (max-min), -min); - applyColorMap(adjMap, falseColorsMap, cv::COLORMAP_JET); + applyColorMap(adjMap, falseColorsMap, cv::COLORMAP_PARULA); } return falseColorsMap; } diff --git a/tests/monodepth2/monodepth2.cpp b/tests/monodepth2/monodepth2.cpp index c763baf..4e0767a 100644 --- a/tests/monodepth2/monodepth2.cpp +++ b/tests/monodepth2/monodepth2.cpp @@ -3,6 +3,7 @@ #include #include #include +#include "tkDNN/NetworkViz.h" const char* encoder_conv1_bin = "monodepth2/layers/encoder/encoder-conv1.bin"; const char* encoder_layer1_bin[] = { @@ -72,108 +73,111 @@ int main(){ tk::dnn::dataDim_t dim(1,3,192,640,1); tk::dnn::Network net(dim); - tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin,true,false,1,true); + + tk::dnn::Layer* muladd_sub = new tk::dnn::MulAdd(&net, 1.0f, -0.45f); + tk::dnn::Layer* muladd_mul = new tk::dnn::MulAdd(&net, 1.0f / 0.225f, 0.0f); + tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin,true); tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); //layer-1 - tk::dnn::Layer* encoder_layer_1_0_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_layer_1_0_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[0],true); tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_0_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_1_0_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[1],true); tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_1_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_1_1_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[2],true); tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_1_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_layer_1_1_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[3],true); tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); //layer-2 - tk::dnn::Layer* encoder_layer_2_0_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_0_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true); tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_0_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_0_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true); tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); - tk::dnn::Layer* encoder_layer_2_0_downsample_convbn = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_0_downsample_convbn = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2],true); tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_convbn_2); tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_1_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_1_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true); tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_1_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true,false,1,true); + tk::dnn::Layer* encoder_layer_2_1_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true); tk::dnn::Layer* encoder_layer_2_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); //layer-3 - tk::dnn::Layer* encoder_layer_3_0_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_0_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true); tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_0_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_0_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true); tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); - tk::dnn::Layer* encoder_layer_3_0_downsample_convbn = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_0_downsample_convbn = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2],true); tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_convbn_2); tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_1_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_1_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true); tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_1_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true,false,1,true); + tk::dnn::Layer* encoder_layer_3_1_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true); tk::dnn::Layer* encoder_layer_3_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); //layer-4 - tk::dnn::Layer* encoder_layer_4_0_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_0_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true); tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_0_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_0_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true); tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); - tk::dnn::Layer* encoder_layer_4_0_downsample_convbn = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_0_downsample_convbn = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2],true); tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_convbn_2); tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_1_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_1_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true); tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_1_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true,false,1,true); + tk::dnn::Layer* encoder_layer_4_1_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true); tk::dnn::Layer* encoder_layer_4_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); //decoder tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); - tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); - tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); - tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); - tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); - tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); - tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); - tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); - tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); - tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); - tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); + tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); @@ -240,13 +244,17 @@ int main(){ dnnType *cudnn_out, *rt_out; cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT.buffersRT[i]; + rt_out = (dnnType *)netRT.buffersRT[1+i]; std::cout<<"CUDNN vs correct"; ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; std::cout<<"TRT vs correct"; ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + + cv::Mat depth_mat = vizData2Mat(outs[i]->dstData, outs[i]->output_dim, outs[i]->output_dim.h, outs[i]->output_dim.w); + cv::imshow("depth", depth_mat); + cv::waitKey(0); } -- 2.52.0 From decd73d29889859110da3ed7a32a0a4b532605f2 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Wed, 19 Jan 2022 10:22:06 -0800 Subject: [PATCH 50/58] Fix saving result video in demoDepth, add automatic download for monodepth2 weights Signed-off-by: Micaela Verucchi --- demo/demo/demoDepth.cpp | 9 ++++++--- include/tkDNN/DepthNN.h | 6 ++++++ tests/monodepth2/monodepth2.cpp | 6 ++++-- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/demo/demo/demoDepth.cpp b/demo/demo/demoDepth.cpp index eda04c6..41f5dbf 100644 --- a/demo/demo/demoDepth.cpp +++ b/demo/demo/demoDepth.cpp @@ -55,9 +55,9 @@ int main(int argc, char *argv[]) { cv::VideoWriter resultVideo; 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)); + int w = depthNN.output_w; + int h = depthNN.output_h; + resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','J','P','G'), 30, cv::Size(w, h)); } if(show) @@ -87,6 +87,9 @@ int main(int argc, char *argv[]) { cv::waitKey(1); } + + if(save) + resultVideo << depthNN.depthMats[0]; } std::cout<<"detection end\n"; diff --git a/include/tkDNN/DepthNN.h b/include/tkDNN/DepthNN.h index 0d89ac0..4d34239 100644 --- a/include/tkDNN/DepthNN.h +++ b/include/tkDNN/DepthNN.h @@ -30,6 +30,9 @@ class DepthNN { dnnType *input_d; float* depth_h; + int output_w; + int output_h; + int nBatches = 1; cv::Mat bgr[3]; @@ -68,6 +71,9 @@ class DepthNN { depths[i].resize(netRT->buffersDIM[1].tot()); depth_h = (float *)malloc(netRT->buffersDIM[1].tot() * sizeof(float)); + + output_h = netRT->buffersDIM[1].h; + output_w = netRT->buffersDIM[1].w; } diff --git a/tests/monodepth2/monodepth2.cpp b/tests/monodepth2/monodepth2.cpp index 4e0767a..8618539 100644 --- a/tests/monodepth2/monodepth2.cpp +++ b/tests/monodepth2/monodepth2.cpp @@ -66,11 +66,13 @@ const char* output_bin[] = { "monodepth2/debug/outputs/output-disp-3.bin" }; -const char* input_monodepth2_bin[] = {"monodepth2/debug/input.bin","monodepth2/debug/input2.bin"}; +const char* input_bin = "monodepth2/debug/input.bin"; int main(){ + downloadWeightsifDoNotExist(input_bin, "monodepth2", "https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download"); + tk::dnn::dataDim_t dim(1,3,192,640,1); tk::dnn::Network net(dim); @@ -204,7 +206,7 @@ int main(){ dnnType *data; dnnType *input_H; - readBinaryFile(input_monodepth2_bin[0],dim.tot(),&input_H,&data); + readBinaryFile(input_bin, dim.tot(),&input_H,&data); std::cout<<"INPUT DIMENSIONS : "< Date: Thu, 20 Jan 2022 00:52:22 +0530 Subject: [PATCH 51/58] -Replaced ISliceLayer based paddings(reflection,constant and zero) with the IPluginV2 version for TensorRT >= 8.2.0 -Fixed demo build issue on Windows Signed-off-by: perseusdg --- demo/demo/demo.cpp | 6 +++--- src/NetworkRT.cpp | 9 ++++----- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 6de7214..f46ca80 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -46,9 +46,9 @@ int main(int argc, char *argv[]) { 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"); + 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."); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 9b5f14c..71e45ed 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -571,7 +571,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ float(NV_TENSORRT_MINOR)/10 + float(NV_TENSORRT_PATCH)/100; -#if ((NV_TENSORRT_MAJOR == 8 && NV_TENSORRT_MINOR >= 2) || NV_TENSORRT_MAJOR > 8) +/*#if ((NV_TENSORRT_MAJOR == 8 && NV_TENSORRT_MINOR >= 2) || NV_TENSORRT_MAJOR > 8) auto *lRT = networkRT->addSlice(*input,Dims3{0,0,0},Dims3{l->output_dim.c,l->output_dim.h,l->output_dim.w},Dims3{0,0,0}); if(l->padding_mode == PADDING_MODE_REFLECTION){ lRT->setMode(SliceMode::kREFLECT); @@ -581,8 +581,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ } checkNULL(lRT); return lRT; -#else - //todo add PADDING_MODE_CONSTANT AND PADDING_MODE_ZERO for tensorrt versions < 8.2 +#else*/ + //todo use ISliceLayer for padding,currently using ISliceLayer for reflection padding generates an error with monodepth2 if(l->padding_mode == PADDING_MODE_REFLECTION){ auto creator = getPluginRegistry()->getPluginCreator("ReflectionPaddingRT_tkDNN","1"); std::vector mPluginAttributes; @@ -623,8 +623,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input,Padding *l){ } return nullptr; - -#endif + } ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { -- 2.52.0 From 3e86671c5073414a43079f2ce5002d709eba1e7b Mon Sep 17 00:00:00 2001 From: Harshvardhan Chandirasekar <43143075+perseusdg@users.noreply.github.com> Date: Mon, 24 Jan 2022 21:41:59 +0530 Subject: [PATCH 52/58] Moved batchnorm and test_monodepth2_new_format layer to dev Signed-off-by: perseusdg --- CMakeLists.txt | 3 - include/tkDNN/Layer.h | 78 ------ src/BatchNorm.cpp | 67 ----- src/LayerBNWgs.cpp | 88 ------ tests/monodepth2/monodepth2_new_format.cpp | 306 --------------------- 5 files changed, 542 deletions(-) delete mode 100644 src/BatchNorm.cpp delete mode 100644 src/LayerBNWgs.cpp delete mode 100644 tests/monodepth2/monodepth2_new_format.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a109c36..7392fd8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -207,9 +207,6 @@ target_link_libraries(test_shelfnet_mapillary tkDNN) add_executable(test_monodepth2 tests/monodepth2/monodepth2.cpp) target_link_libraries(test_monodepth2 tkDNN) -add_executable(test_monodepth2_new_format tests/monodepth2/monodepth2_new_format.cpp) -target_link_libraries(test_monodepth2_new_format tkDNN) - # DEMOS add_executable(test_rtinference tests/test_rtinference/rtinference.cpp) target_link_libraries(test_rtinference tkDNN) diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 1e22216..daa27e5 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -33,7 +33,6 @@ enum layerType_t { LAYER_REGION, LAYER_YOLO, LAYER_PADDING, - LAYER_BATCHNORM }; #define TKDNN_BN_MIN_EPSILON 1e-5 @@ -90,7 +89,6 @@ public: case LAYER_REGION: return "Region"; case LAYER_YOLO: return "Yolo"; case LAYER_PADDING: return "Padding"; - case LAYER_BATCHNORM: return "BatchNorm"; default: return "unknown"; } } @@ -182,65 +180,6 @@ public: }; -class LayerBNWgs : public Layer { -public: - LayerBNWgs(Network* net, int input, int output, std::string fname_weights); - ~LayerBNWgs(); - - int inputs, outputs; - std::string weights_path; - - dnnType* bias_h, * bias_d; - dnnType* power_h = nullptr; - dnnType* scales_h = nullptr, * scales_d = nullptr; - dnnType* mean_h = nullptr, * mean_d = nullptr; - dnnType* variance_h = nullptr, * variance_d = nullptr; - - __half* bias16_h = nullptr, * bias16_d = nullptr; - __half* power16_h = nullptr, * power16_d = nullptr; - __half* scales16_h = nullptr, * scales16_d = nullptr; - __half* mean16_h = nullptr, * mean16_d = nullptr; - __half* variance16_h = nullptr, * variance16_d = nullptr; - - - void releaseHost(bool release32 = true, bool release16 = true) { - if (release32) { - if (bias_h != nullptr) { delete[] bias_h; bias_h = nullptr; } - if (scales_h != nullptr) { delete[] scales_h; scales_h = nullptr; } - if (mean_h != nullptr) { delete[] mean_h; mean_h = nullptr; } - if (variance_h != nullptr) { delete[] variance_h; variance_h = nullptr; } - if (power_h != nullptr) { delete[] power_h; power_h = nullptr; } - } - if (net->fp16 && release16) { - if (bias16_h != nullptr) { delete[] bias16_h; bias16_h = nullptr; } - if (scales16_h != nullptr) { delete[] scales16_h; scales16_h = nullptr; } - if (mean16_h != nullptr) { delete[] mean16_h; mean16_h = nullptr; } - if (variance16_h != nullptr) { delete[] variance16_h; variance16_h = nullptr; } - if (power16_h != nullptr) { delete[] power16_h; power16_h = nullptr; } - - } - } - - void releaseDevice(bool release32 = true, bool release16 = true) { - if (release32) { - if (bias_d != nullptr) { cudaFree(bias_d); bias_d = nullptr; } - if (scales_d != nullptr) { cudaFree(scales_d); scales_d = nullptr; } - if (mean_d != nullptr) { cudaFree(mean_d); mean_d = nullptr; } - if (variance_d != nullptr) { cudaFree(variance_d); variance_d = nullptr; } - } - if (net->fp16 && release16) { - if (bias16_d != nullptr) { cudaFree(bias16_d); bias16_d = nullptr; } - if (scales16_d != nullptr) { cudaFree(scales16_d); scales16_d = nullptr; } - if (mean16_d != nullptr) { cudaFree(mean16_d); mean16_d = nullptr; } - if (variance16_d != nullptr) { cudaFree(variance16_d); variance16_d = nullptr; } - if (power16_d != nullptr) { cudaFree(power16_d); power16_d = nullptr; } - } - } - - - -}; - /** Input layer (it doesn't need weights) */ @@ -606,24 +545,7 @@ public: }; -class BatchNorm : public LayerBNWgs { -public: - BatchNorm(Network *net,int output,std::string fname_weights); - virtual ~BatchNorm(); - virtual layerType_t getLayerType(){return LAYER_BATCHNORM;}; - virtual dnnType* infer(dataDim_t& dim,dnnType* srcData); - std::string weights_bin; -protected: - cudnnFilterDescriptor_t filterDesc; - cudnnConvolutionFwdAlgoPerf_t algo; - cudnnConvolutionBwdDataAlgoPerf_t bwAlgo; - cudnnTensorDescriptor_t biasTensorDesc; - void initCUDNN(); - void inferCUDNN(dnnType* srcData); - void* workSpace; - size_t ws_sizeInBytes; -}; /** Softmax layer */ diff --git a/src/BatchNorm.cpp b/src/BatchNorm.cpp deleted file mode 100644 index b406011..0000000 --- a/src/BatchNorm.cpp +++ /dev/null @@ -1,67 +0,0 @@ -#include - -#include "Layer.h" - -namespace tk { namespace dnn { - void BatchNorm::initCUDNN(){ - cudnnTensorDescriptor_t srcTensor = srcTensorDesc; - cudnnTensorDescriptor_t dstTensor = dstTensorDesc; - dataDim_t idim,odim; - idim = input_dim; - odim = output_dim; - - checkCUDNN( cudnnSetTensor4dDescriptor(srcTensor, - net->tensorFormat, net->dataType, idim.n, idim.c, idim.h, idim.w) ); - - checkCUDNN( cudnnCreateTensorDescriptor(&biasTensorDesc) ); - - checkCUDNN( cudnnSetTensor4dDescriptor(dstTensor, - net->tensorFormat, net->dataType, odim.n, odim.c, odim.h, odim.w) ); - - checkCUDNN( cudnnSetTensor4dDescriptor(biasTensorDesc, - net->tensorFormat, net->dataType, - 1, output_dim.c, 1, 1) ); - - - } - - void BatchNorm::inferCUDNN(float *srcData){ - dnnType alpha = dnnType(1); - dnnType beta = dnnType(0); - - alpha = dnnType(1); - beta = dnnType(1); - checkCUDNN( cudnnAddTensor(net->cudnnHandle, - &alpha, biasTensorDesc, bias_d, - &beta, dstTensorDesc, dstData) ); - alpha = dnnType(1); - beta = dnnType(0); - checkCUDNN( cudnnBatchNormalizationForwardInference(net->cudnnHandle, - CUDNN_BATCHNORM_SPATIAL, &alpha, &beta, - dstTensorDesc, dstData, dstTensorDesc, - dstData, biasTensorDesc, //same tensor descriptor as bias - scales_d, bias_d, mean_d, variance_d, - TKDNN_BN_MIN_EPSILON) ); - } - - BatchNorm::BatchNorm(Network *net,int output,std::string fname_weights) : - LayerBNWgs(net,net->getOutputDim().c,output,fname_weights){ - output_dim = input_dim; - initCUDNN(); - checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); - - } - - dnnType* BatchNorm::infer(dataDim_t &dim,dnnType* srcData){ - inferCUDNN(srcData); - - dim = output_dim; - return dstData; - } - - BatchNorm::~BatchNorm(){ - checkCUDNN( cudnnDestroyTensorDescriptor(biasTensorDesc) ); - checkCuda( cudaFree(dstData) ); - } - -}} \ No newline at end of file diff --git a/src/LayerBNWgs.cpp b/src/LayerBNWgs.cpp deleted file mode 100644 index 7414ef3..0000000 --- a/src/LayerBNWgs.cpp +++ /dev/null @@ -1,88 +0,0 @@ -#include -#include - -#include "Layer.h" -#include "kernels.h" - -namespace tk { namespace dnn { - LayerBNWgs::LayerBNWgs(Network* net, int input, int output, std::string fname_weights) : Layer(net) { - this->inputs = inputs; - this->outputs = output; - this->weights_path = fname_weights; - - std::cout << "Reading BatchNorm O = " << outputs << std::endl; - int seek = 0; - readBinaryFile(weights_path.c_str(), outputs, &bias_h, &bias_d, seek); - seek += outputs; - readBinaryFile(weights_path.c_str(), outputs, &scales_h, &scales_d, seek); - seek += outputs; - readBinaryFile(weights_path.c_str(), outputs, &mean_h, &mean_d, seek); - seek += outputs; - readBinaryFile(weights_path.c_str(), outputs, &variance_h, &variance_d, seek); - seek += outputs; - - float eps = TKDNN_BN_MIN_EPSILON; - - power_h = new dnnType[outputs]; - for (int i = 0; i < outputs; i++) power_h[i] = 1.0f; - - for (int i = 0; i < outputs; i++) - mean_h[i] = mean_h[i] / -sqrt(eps + variance_h[i]); - - for (int i = 0; i < outputs; i++) - variance_h[i] = 1.0f / sqrt(eps + variance_h[i]); - - if (!net->fp16) - return; - - int b_size = outputs; - bias16_h = new __half[b_size]; - cudaMalloc(&bias16_d, b_size * sizeof(__half)); - float2half(bias_d, bias16_d, b_size); - cudaMemcpy(bias16_h, bias16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - power16_h = new __half[b_size]; - mean16_h = new __half[b_size]; - variance16_h = new __half[b_size]; - scales16_h = new __half[b_size]; - - cudaMalloc(&power16_d, b_size * sizeof(__half)); - cudaMalloc(&mean16_d, b_size * sizeof(__half)); - cudaMalloc(&variance16_d, b_size * sizeof(__half)); - cudaMalloc(&scales16_d, b_size * sizeof(__half)); - - //temporary buffers - float* tmp_d; - cudaMalloc(&tmp_d, b_size * sizeof(float)); - - //init power array of ones - cudaMemcpy(tmp_d, power_h, b_size * sizeof(float), cudaMemcpyHostToDevice); - float2half(tmp_d, power16_d, b_size); - cudaMemcpy(power16_h, power16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - //mean array - cudaMemcpy(tmp_d, mean_h, b_size * sizeof(float), cudaMemcpyHostToDevice); - float2half(tmp_d, mean16_d, b_size); - cudaMemcpy(mean16_h, mean16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - //convert variance - - cudaMemcpy(tmp_d, variance_h, b_size * sizeof(float), cudaMemcpyHostToDevice); - float2half(tmp_d, variance16_d, b_size); - cudaMemcpy(variance16_h, variance16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - //convert scales - float2half(scales_d, scales16_d, b_size); - cudaMemcpy(scales16_h, scales16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - cudaFree(tmp_d); - - - } - - LayerBNWgs::~LayerBNWgs() { - releaseHost(); - releaseDevice(); - } - -} } \ No newline at end of file diff --git a/tests/monodepth2/monodepth2_new_format.cpp b/tests/monodepth2/monodepth2_new_format.cpp deleted file mode 100644 index 313978c..0000000 --- a/tests/monodepth2/monodepth2_new_format.cpp +++ /dev/null @@ -1,306 +0,0 @@ -#include -#include -#include -#include -#include - -const char* encoder_conv1_bin = "monodepth2/layers/encoder/encoder-conv1.bin"; -const char* encoder_bn1_bin = "monodepth2/layers/encoder/encoder-bn1.bin"; - -const char* encoder_layer1_conv_bin[] = { - "monodepth2/layers/encoder/encoder-layer1-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer1-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer1-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer1-1-conv2.bin", -}; - -const char* encoder_layer1_bn_bin[] = { - "monodepth2/layers/encoder/encoder-layer1-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer1-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer1-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer1-1-bn2.bin", -}; - - - -const char* encoder_layer2_conv_bin[] = { - "monodepth2/layers/encoder/encoder-layer2-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer2-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer2-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer2-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-conv2.bin" -}; - -const char* encoder_layer2_bn_bin[] = { - "monodepth2/layers/encoder/encoder-layer2-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer2-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer2-0-downsample-1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-bn2.bin" -}; - -const char* encoder_layer3_conv_bin[]={ - "monodepth2/layers/encoder/encoder-layer3-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer3-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer3-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer3-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-conv2.bin" -}; - -const char* encoder_layer3_bn_bin[]={ - "monodepth2/layers/encoder/encoder-layer3-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer3-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer3-0-downsample-1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-bn2.bin" -}; - -const char* encoder_layer4_conv_bin[] = { - "monodepth2/layers/encoder/encoder-layer4-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer4-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer4-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer4-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-conv2.bin" -}; - -const char* encoder_layer4_bn_bin[] = { - "monodepth2/layers/encoder/encoder-layer4-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer4-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer4-0-downsample-1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-bn2.bin" -}; - -const char* decoder_layer_bin[] = { - "monodepth2/layers/depth_decoder/decoder-0-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-1-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-2-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-3-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-4-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-5-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-6-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-7-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-8-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-9-conv-conv.bin" -}; - -const char* decoder_dispconv_layer_bin[] = { - "monodepth2/layers/depth_decoder/decoder-10-conv.bin", - "monodepth2/layers/depth_decoder/decoder-11-conv.bin", - "monodepth2/layers/depth_decoder/decoder-12-conv.bin", - "monodepth2/layers/depth_decoder/decoder-13-conv.bin" -}; - -const char* output_bin[] = { - "monodepth2/debug/outputs/output-disp-0.bin", - "monodepth2/debug/outputs/output-disp-1.bin", - "monodepth2/debug/outputs/output-disp-2.bin", - "monodepth2/debug/outputs/output-disp-3.bin" -}; - -const char* input_monodepth2_bin[] = {"monodepth2/debug/input.bin","monodepth2/debug/input2.bin"}; - -int main(){ - tk::dnn::dataDim_t dim(1,3,192,640,1); - tk::dnn::Network net(dim); - tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin); - tk::dnn::Layer* encoder_bn = new tk::dnn::BatchNorm(&net,64,encoder_bn1_bin); - tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); - - //layer-1 - tk::dnn::Layer* encoder_layer_1_0_conv_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[0]); - tk::dnn::Layer* encoder_layer_1_0_bn_1 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[0]); - tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_0_conv_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[1]); - tk::dnn::Layer* encoder_layer_1_0_bn_2 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[1]); - tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); - tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_1_conv_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[2]); - tk::dnn::Layer* encoder_layer_1_1_bn_1 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[2]); - tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_1_conv_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[3]); - tk::dnn::Layer* encoder_layer_1_1_bn_2 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[3]); - tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); - tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - //layer-2 - tk::dnn::Layer* encoder_layer_2_0_conv_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_conv_bin[0]); - tk::dnn::Layer* encoder_layer_2_0_bn_1 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[0]); - tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_0_conv_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[1]); - tk::dnn::Layer* encoder_layer_2_0_bn_2 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[1]); - tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); - tk::dnn::Layer* encoder_layer_2_0_downsample_conv = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_conv_bin[2]); - tk::dnn::Layer* encoder_layer_2_0_downsample_bn = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[2]); - tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_downsample_bn); - tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_1_conv_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[3]); - tk::dnn::Layer* encoder_layer_2_1_bn_1 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[3]); - tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_1_conv_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[4]); - tk::dnn::Layer* encoder_layer_2_1_bn_2 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[4]); - tk::dnn::Layer* encoder_layer_2_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); - tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - //layer-3 - tk::dnn::Layer* encoder_layer_3_0_conv_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_conv_bin[0]); - tk::dnn::Layer* encoder_layer_3_0_bn_1 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[0]); - tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_0_conv_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[1]); - tk::dnn::Layer* encoder_layer_3_0_bn_2 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[1]); - tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); - tk::dnn::Layer* encoder_layer_3_0_downsample_conv = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_conv_bin[2]); - tk::dnn::Layer* encoder_layer_3_0_downsample_bn = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[2]); - tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_bn_2); - tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_1_conv_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[3]); - tk::dnn::Layer* encoder_layer_3_1_bn_1 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[3]); - tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_1_conv_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[4]); - tk::dnn::Layer* encoder_layer_3_1_bn_2 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[4]); - tk::dnn::Layer* encoder_layer_3_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); - tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - //layer-4 - tk::dnn::Layer* encoder_layer_4_0_conv_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_conv_bin[0]); - tk::dnn::Layer* encoder_layer_4_0_bn_1 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[0]); - tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_0_conv_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[1]); - tk::dnn::Layer* encoder_layer_4_0_bn_2 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[1]); - tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); - tk::dnn::Layer* encoder_layer_4_0_downsample_conv = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_conv_bin[2]); - tk::dnn::Layer* encoder_layer_4_0_downsample_bn = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[2]); - tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_bn_2); - tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_1_conv_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[3]); - tk::dnn::Layer* encoder_layer_4_1_bn_1 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[3]); - tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_1_conv_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[4]); - tk::dnn::Layer* encoder_layer_4_1_bn_2 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[4]); - tk::dnn::Layer* encoder_layer_4_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); - tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - - //decoder - tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); - tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; - tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); - tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); - tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); - tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; - tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; - tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); - tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); - tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; - tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); - tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); - tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); - tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; - tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); - tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); - tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); - tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); - tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); - tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp0->setFinal(); - - tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); - tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); - tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp1->setFinal(); - - tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); - tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); - tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp2->setFinal(); - - tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); - tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); - tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp3->setFinal(); - - dnnType *data; - dnnType *input_H; - readBinaryFile(input_monodepth2_bin[1],dim.tot(),&input_H,&data); - std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); - int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; - for(int i=0;i<4;i++){ - printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); - outs[i]->output_dim.print(); - - dnnType *out, *out_h; - int odim = outs[i]->output_dim.tot(); - readBinaryFile(output_bin[i], odim, &out_h, &out); - - dnnType *cudnn_out, *rt_out; - cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT.buffersRT[i]; - std::cout<<"CUDNN vs correct"; - ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; - std::cout<<"TRT vs correct"; - ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; - std::cout<<"CUDNN vs TRT "; - ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - } - - - return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; - -} \ No newline at end of file -- 2.52.0 From afdad8e6612051fde57392c91779fb0dcf5f90e5 Mon Sep 17 00:00:00 2001 From: Harshvardhan Chandirasekar <43143075+perseusdg@users.noreply.github.com> Date: Mon, 24 Jan 2022 21:41:59 +0530 Subject: [PATCH 53/58] Moved batchnorm and test_monodepth2_new_format layer to dev Signed-off-by: perseusdg --- CMakeLists.txt | 3 - include/tkDNN/Layer.h | 78 ------ include/tkDNN/NetworkRT.h | 1 - src/BatchNorm.cpp | 67 ----- src/LayerBNWgs.cpp | 88 ------ src/NetworkRT.cpp | 34 --- tests/monodepth2/monodepth2_new_format.cpp | 306 --------------------- 7 files changed, 577 deletions(-) delete mode 100644 src/BatchNorm.cpp delete mode 100644 src/LayerBNWgs.cpp delete mode 100644 tests/monodepth2/monodepth2_new_format.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a109c36..7392fd8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -207,9 +207,6 @@ target_link_libraries(test_shelfnet_mapillary tkDNN) add_executable(test_monodepth2 tests/monodepth2/monodepth2.cpp) target_link_libraries(test_monodepth2 tkDNN) -add_executable(test_monodepth2_new_format tests/monodepth2/monodepth2_new_format.cpp) -target_link_libraries(test_monodepth2_new_format tkDNN) - # DEMOS add_executable(test_rtinference tests/test_rtinference/rtinference.cpp) target_link_libraries(test_rtinference tkDNN) diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 1e22216..daa27e5 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -33,7 +33,6 @@ enum layerType_t { LAYER_REGION, LAYER_YOLO, LAYER_PADDING, - LAYER_BATCHNORM }; #define TKDNN_BN_MIN_EPSILON 1e-5 @@ -90,7 +89,6 @@ public: case LAYER_REGION: return "Region"; case LAYER_YOLO: return "Yolo"; case LAYER_PADDING: return "Padding"; - case LAYER_BATCHNORM: return "BatchNorm"; default: return "unknown"; } } @@ -182,65 +180,6 @@ public: }; -class LayerBNWgs : public Layer { -public: - LayerBNWgs(Network* net, int input, int output, std::string fname_weights); - ~LayerBNWgs(); - - int inputs, outputs; - std::string weights_path; - - dnnType* bias_h, * bias_d; - dnnType* power_h = nullptr; - dnnType* scales_h = nullptr, * scales_d = nullptr; - dnnType* mean_h = nullptr, * mean_d = nullptr; - dnnType* variance_h = nullptr, * variance_d = nullptr; - - __half* bias16_h = nullptr, * bias16_d = nullptr; - __half* power16_h = nullptr, * power16_d = nullptr; - __half* scales16_h = nullptr, * scales16_d = nullptr; - __half* mean16_h = nullptr, * mean16_d = nullptr; - __half* variance16_h = nullptr, * variance16_d = nullptr; - - - void releaseHost(bool release32 = true, bool release16 = true) { - if (release32) { - if (bias_h != nullptr) { delete[] bias_h; bias_h = nullptr; } - if (scales_h != nullptr) { delete[] scales_h; scales_h = nullptr; } - if (mean_h != nullptr) { delete[] mean_h; mean_h = nullptr; } - if (variance_h != nullptr) { delete[] variance_h; variance_h = nullptr; } - if (power_h != nullptr) { delete[] power_h; power_h = nullptr; } - } - if (net->fp16 && release16) { - if (bias16_h != nullptr) { delete[] bias16_h; bias16_h = nullptr; } - if (scales16_h != nullptr) { delete[] scales16_h; scales16_h = nullptr; } - if (mean16_h != nullptr) { delete[] mean16_h; mean16_h = nullptr; } - if (variance16_h != nullptr) { delete[] variance16_h; variance16_h = nullptr; } - if (power16_h != nullptr) { delete[] power16_h; power16_h = nullptr; } - - } - } - - void releaseDevice(bool release32 = true, bool release16 = true) { - if (release32) { - if (bias_d != nullptr) { cudaFree(bias_d); bias_d = nullptr; } - if (scales_d != nullptr) { cudaFree(scales_d); scales_d = nullptr; } - if (mean_d != nullptr) { cudaFree(mean_d); mean_d = nullptr; } - if (variance_d != nullptr) { cudaFree(variance_d); variance_d = nullptr; } - } - if (net->fp16 && release16) { - if (bias16_d != nullptr) { cudaFree(bias16_d); bias16_d = nullptr; } - if (scales16_d != nullptr) { cudaFree(scales16_d); scales16_d = nullptr; } - if (mean16_d != nullptr) { cudaFree(mean16_d); mean16_d = nullptr; } - if (variance16_d != nullptr) { cudaFree(variance16_d); variance16_d = nullptr; } - if (power16_d != nullptr) { cudaFree(power16_d); power16_d = nullptr; } - } - } - - - -}; - /** Input layer (it doesn't need weights) */ @@ -606,24 +545,7 @@ public: }; -class BatchNorm : public LayerBNWgs { -public: - BatchNorm(Network *net,int output,std::string fname_weights); - virtual ~BatchNorm(); - virtual layerType_t getLayerType(){return LAYER_BATCHNORM;}; - virtual dnnType* infer(dataDim_t& dim,dnnType* srcData); - std::string weights_bin; -protected: - cudnnFilterDescriptor_t filterDesc; - cudnnConvolutionFwdAlgoPerf_t algo; - cudnnConvolutionBwdDataAlgoPerf_t bwAlgo; - cudnnTensorDescriptor_t biasTensorDesc; - void initCUDNN(); - void inferCUDNN(dnnType* srcData); - void* workSpace; - size_t ws_sizeInBytes; -}; /** Softmax layer */ diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 146ea4c..6457068 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -98,7 +98,6 @@ public: nvinfer1::IResizeLayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input,Padding *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor* input,BatchNorm *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor* input,MulAdd *l); #if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 diff --git a/src/BatchNorm.cpp b/src/BatchNorm.cpp deleted file mode 100644 index b406011..0000000 --- a/src/BatchNorm.cpp +++ /dev/null @@ -1,67 +0,0 @@ -#include - -#include "Layer.h" - -namespace tk { namespace dnn { - void BatchNorm::initCUDNN(){ - cudnnTensorDescriptor_t srcTensor = srcTensorDesc; - cudnnTensorDescriptor_t dstTensor = dstTensorDesc; - dataDim_t idim,odim; - idim = input_dim; - odim = output_dim; - - checkCUDNN( cudnnSetTensor4dDescriptor(srcTensor, - net->tensorFormat, net->dataType, idim.n, idim.c, idim.h, idim.w) ); - - checkCUDNN( cudnnCreateTensorDescriptor(&biasTensorDesc) ); - - checkCUDNN( cudnnSetTensor4dDescriptor(dstTensor, - net->tensorFormat, net->dataType, odim.n, odim.c, odim.h, odim.w) ); - - checkCUDNN( cudnnSetTensor4dDescriptor(biasTensorDesc, - net->tensorFormat, net->dataType, - 1, output_dim.c, 1, 1) ); - - - } - - void BatchNorm::inferCUDNN(float *srcData){ - dnnType alpha = dnnType(1); - dnnType beta = dnnType(0); - - alpha = dnnType(1); - beta = dnnType(1); - checkCUDNN( cudnnAddTensor(net->cudnnHandle, - &alpha, biasTensorDesc, bias_d, - &beta, dstTensorDesc, dstData) ); - alpha = dnnType(1); - beta = dnnType(0); - checkCUDNN( cudnnBatchNormalizationForwardInference(net->cudnnHandle, - CUDNN_BATCHNORM_SPATIAL, &alpha, &beta, - dstTensorDesc, dstData, dstTensorDesc, - dstData, biasTensorDesc, //same tensor descriptor as bias - scales_d, bias_d, mean_d, variance_d, - TKDNN_BN_MIN_EPSILON) ); - } - - BatchNorm::BatchNorm(Network *net,int output,std::string fname_weights) : - LayerBNWgs(net,net->getOutputDim().c,output,fname_weights){ - output_dim = input_dim; - initCUDNN(); - checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); - - } - - dnnType* BatchNorm::infer(dataDim_t &dim,dnnType* srcData){ - inferCUDNN(srcData); - - dim = output_dim; - return dstData; - } - - BatchNorm::~BatchNorm(){ - checkCUDNN( cudnnDestroyTensorDescriptor(biasTensorDesc) ); - checkCuda( cudaFree(dstData) ); - } - -}} \ No newline at end of file diff --git a/src/LayerBNWgs.cpp b/src/LayerBNWgs.cpp deleted file mode 100644 index 7414ef3..0000000 --- a/src/LayerBNWgs.cpp +++ /dev/null @@ -1,88 +0,0 @@ -#include -#include - -#include "Layer.h" -#include "kernels.h" - -namespace tk { namespace dnn { - LayerBNWgs::LayerBNWgs(Network* net, int input, int output, std::string fname_weights) : Layer(net) { - this->inputs = inputs; - this->outputs = output; - this->weights_path = fname_weights; - - std::cout << "Reading BatchNorm O = " << outputs << std::endl; - int seek = 0; - readBinaryFile(weights_path.c_str(), outputs, &bias_h, &bias_d, seek); - seek += outputs; - readBinaryFile(weights_path.c_str(), outputs, &scales_h, &scales_d, seek); - seek += outputs; - readBinaryFile(weights_path.c_str(), outputs, &mean_h, &mean_d, seek); - seek += outputs; - readBinaryFile(weights_path.c_str(), outputs, &variance_h, &variance_d, seek); - seek += outputs; - - float eps = TKDNN_BN_MIN_EPSILON; - - power_h = new dnnType[outputs]; - for (int i = 0; i < outputs; i++) power_h[i] = 1.0f; - - for (int i = 0; i < outputs; i++) - mean_h[i] = mean_h[i] / -sqrt(eps + variance_h[i]); - - for (int i = 0; i < outputs; i++) - variance_h[i] = 1.0f / sqrt(eps + variance_h[i]); - - if (!net->fp16) - return; - - int b_size = outputs; - bias16_h = new __half[b_size]; - cudaMalloc(&bias16_d, b_size * sizeof(__half)); - float2half(bias_d, bias16_d, b_size); - cudaMemcpy(bias16_h, bias16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - power16_h = new __half[b_size]; - mean16_h = new __half[b_size]; - variance16_h = new __half[b_size]; - scales16_h = new __half[b_size]; - - cudaMalloc(&power16_d, b_size * sizeof(__half)); - cudaMalloc(&mean16_d, b_size * sizeof(__half)); - cudaMalloc(&variance16_d, b_size * sizeof(__half)); - cudaMalloc(&scales16_d, b_size * sizeof(__half)); - - //temporary buffers - float* tmp_d; - cudaMalloc(&tmp_d, b_size * sizeof(float)); - - //init power array of ones - cudaMemcpy(tmp_d, power_h, b_size * sizeof(float), cudaMemcpyHostToDevice); - float2half(tmp_d, power16_d, b_size); - cudaMemcpy(power16_h, power16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - //mean array - cudaMemcpy(tmp_d, mean_h, b_size * sizeof(float), cudaMemcpyHostToDevice); - float2half(tmp_d, mean16_d, b_size); - cudaMemcpy(mean16_h, mean16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - //convert variance - - cudaMemcpy(tmp_d, variance_h, b_size * sizeof(float), cudaMemcpyHostToDevice); - float2half(tmp_d, variance16_d, b_size); - cudaMemcpy(variance16_h, variance16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - //convert scales - float2half(scales_d, scales16_d, b_size); - cudaMemcpy(scales16_h, scales16_d, b_size * sizeof(__half), cudaMemcpyDeviceToHost); - - cudaFree(tmp_d); - - - } - - LayerBNWgs::~LayerBNWgs() { - releaseHost(); - releaseDevice(); - } - -} } \ No newline at end of file diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 71e45ed..9177ef2 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -277,8 +277,6 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Layer *l) { return convert_layer(input, (DeformConv2d*) l); if(type == LAYER_PADDING) return convert_layer(input, (Padding*) l); - if(type == LAYER_BATCHNORM) - return convert_layer(input,(BatchNorm*) l); if(type == LAYER_MULADD) return convert_layer(input,(MulAdd*) l); @@ -411,38 +409,6 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input,BatchNorm *l){ - void *bias_b, *power_b, *mean_b, *variance_b, *scales_b; - if(dtRT == DataType::kHALF) { - bias_b = l->bias16_h; - power_b = l->power16_h; - mean_b = l->mean16_h; - variance_b = l->variance16_h; - scales_b = l->scales16_h; - } else { - bias_b = l->bias_h; - power_b = l->power_h; - mean_b = l->mean_h; - variance_b = l->variance_h; - scales_b = l->scales_h; - } - Weights power{dtRT, power_b, l->outputs}; - Weights shift{dtRT, mean_b, l->outputs}; - Weights scale{dtRT, variance_b, l->outputs}; - - IScaleLayer *lRT = networkRT->addScale(*input, ScaleMode::kCHANNEL, - shift, scale, power); - checkNULL(lRT); - Weights shift2{dtRT, bias_b, l->outputs}; - Weights scale2{dtRT, scales_b, l->outputs}; - IScaleLayer *lRT2 = networkRT->addScale(*lRT->getOutput(0), ScaleMode::kCHANNEL, - shift2, scale2, power); - checkNULL(lRT2); - - return lRT2; - -} - ILayer* NetworkRT::convert_layer(ITensor *input,MulAdd *l){ void *power_b, *shift_b, *scales_b; diff --git a/tests/monodepth2/monodepth2_new_format.cpp b/tests/monodepth2/monodepth2_new_format.cpp deleted file mode 100644 index 313978c..0000000 --- a/tests/monodepth2/monodepth2_new_format.cpp +++ /dev/null @@ -1,306 +0,0 @@ -#include -#include -#include -#include -#include - -const char* encoder_conv1_bin = "monodepth2/layers/encoder/encoder-conv1.bin"; -const char* encoder_bn1_bin = "monodepth2/layers/encoder/encoder-bn1.bin"; - -const char* encoder_layer1_conv_bin[] = { - "monodepth2/layers/encoder/encoder-layer1-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer1-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer1-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer1-1-conv2.bin", -}; - -const char* encoder_layer1_bn_bin[] = { - "monodepth2/layers/encoder/encoder-layer1-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer1-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer1-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer1-1-bn2.bin", -}; - - - -const char* encoder_layer2_conv_bin[] = { - "monodepth2/layers/encoder/encoder-layer2-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer2-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer2-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer2-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-conv2.bin" -}; - -const char* encoder_layer2_bn_bin[] = { - "monodepth2/layers/encoder/encoder-layer2-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer2-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer2-0-downsample-1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-bn2.bin" -}; - -const char* encoder_layer3_conv_bin[]={ - "monodepth2/layers/encoder/encoder-layer3-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer3-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer3-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer3-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-conv2.bin" -}; - -const char* encoder_layer3_bn_bin[]={ - "monodepth2/layers/encoder/encoder-layer3-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer3-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer3-0-downsample-1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-bn2.bin" -}; - -const char* encoder_layer4_conv_bin[] = { - "monodepth2/layers/encoder/encoder-layer4-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer4-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer4-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer4-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-conv2.bin" -}; - -const char* encoder_layer4_bn_bin[] = { - "monodepth2/layers/encoder/encoder-layer4-0-bn1.bin", - "monodepth2/layers/encoder/encoder-layer4-0-bn2.bin", - "monodepth2/layers/encoder/encoder-layer4-0-downsample-1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-bn1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-bn2.bin" -}; - -const char* decoder_layer_bin[] = { - "monodepth2/layers/depth_decoder/decoder-0-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-1-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-2-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-3-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-4-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-5-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-6-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-7-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-8-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-9-conv-conv.bin" -}; - -const char* decoder_dispconv_layer_bin[] = { - "monodepth2/layers/depth_decoder/decoder-10-conv.bin", - "monodepth2/layers/depth_decoder/decoder-11-conv.bin", - "monodepth2/layers/depth_decoder/decoder-12-conv.bin", - "monodepth2/layers/depth_decoder/decoder-13-conv.bin" -}; - -const char* output_bin[] = { - "monodepth2/debug/outputs/output-disp-0.bin", - "monodepth2/debug/outputs/output-disp-1.bin", - "monodepth2/debug/outputs/output-disp-2.bin", - "monodepth2/debug/outputs/output-disp-3.bin" -}; - -const char* input_monodepth2_bin[] = {"monodepth2/debug/input.bin","monodepth2/debug/input2.bin"}; - -int main(){ - tk::dnn::dataDim_t dim(1,3,192,640,1); - tk::dnn::Network net(dim); - tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin); - tk::dnn::Layer* encoder_bn = new tk::dnn::BatchNorm(&net,64,encoder_bn1_bin); - tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); - - //layer-1 - tk::dnn::Layer* encoder_layer_1_0_conv_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[0]); - tk::dnn::Layer* encoder_layer_1_0_bn_1 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[0]); - tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_0_conv_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[1]); - tk::dnn::Layer* encoder_layer_1_0_bn_2 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[1]); - tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); - tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_1_conv_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[2]); - tk::dnn::Layer* encoder_layer_1_1_bn_1 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[2]); - tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_1_1_conv_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_conv_bin[3]); - tk::dnn::Layer* encoder_layer_1_1_bn_2 = new tk::dnn::BatchNorm(&net,64,encoder_layer1_bn_bin[3]); - tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); - tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - //layer-2 - tk::dnn::Layer* encoder_layer_2_0_conv_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_conv_bin[0]); - tk::dnn::Layer* encoder_layer_2_0_bn_1 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[0]); - tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_0_conv_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[1]); - tk::dnn::Layer* encoder_layer_2_0_bn_2 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[1]); - tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); - tk::dnn::Layer* encoder_layer_2_0_downsample_conv = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_conv_bin[2]); - tk::dnn::Layer* encoder_layer_2_0_downsample_bn = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[2]); - tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_downsample_bn); - tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_1_conv_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[3]); - tk::dnn::Layer* encoder_layer_2_1_bn_1 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[3]); - tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_2_1_conv_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_conv_bin[4]); - tk::dnn::Layer* encoder_layer_2_1_bn_2 = new tk::dnn::BatchNorm(&net,128,encoder_layer2_bn_bin[4]); - tk::dnn::Layer* encoder_layer_2_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); - tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - //layer-3 - tk::dnn::Layer* encoder_layer_3_0_conv_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_conv_bin[0]); - tk::dnn::Layer* encoder_layer_3_0_bn_1 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[0]); - tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_0_conv_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[1]); - tk::dnn::Layer* encoder_layer_3_0_bn_2 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[1]); - tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); - tk::dnn::Layer* encoder_layer_3_0_downsample_conv = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_conv_bin[2]); - tk::dnn::Layer* encoder_layer_3_0_downsample_bn = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[2]); - tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_bn_2); - tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_1_conv_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[3]); - tk::dnn::Layer* encoder_layer_3_1_bn_1 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[3]); - tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_3_1_conv_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_conv_bin[4]); - tk::dnn::Layer* encoder_layer_3_1_bn_2 = new tk::dnn::BatchNorm(&net,256,encoder_layer3_bn_bin[4]); - tk::dnn::Layer* encoder_layer_3_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); - tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - //layer-4 - tk::dnn::Layer* encoder_layer_4_0_conv_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_conv_bin[0]); - tk::dnn::Layer* encoder_layer_4_0_bn_1 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[0]); - tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_0_conv_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[1]); - tk::dnn::Layer* encoder_layer_4_0_bn_2 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[1]); - tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); - tk::dnn::Layer* encoder_layer_4_0_downsample_conv = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_conv_bin[2]); - tk::dnn::Layer* encoder_layer_4_0_downsample_bn = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[2]); - tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_bn_2); - tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_1_conv_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[3]); - tk::dnn::Layer* encoder_layer_4_1_bn_1 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[3]); - tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - tk::dnn::Layer* encoder_layer_4_1_conv_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_conv_bin[4]); - tk::dnn::Layer* encoder_layer_4_1_bn_2 = new tk::dnn::BatchNorm(&net,512,encoder_layer4_bn_bin[4]); - tk::dnn::Layer* encoder_layer_4_1_shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); - tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); - - - //decoder - tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); - tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; - tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); - tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); - tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); - tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; - tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; - tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); - tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); - tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; - tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); - tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); - tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); - tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; - tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); - tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); - tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); - tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); - tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); - tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_ELU); - tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); - tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp0->setFinal(); - - tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); - tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); - tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp1->setFinal(); - - tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); - tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); - tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp2->setFinal(); - - tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); - tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); - tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); - tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); - disp3->setFinal(); - - dnnType *data; - dnnType *input_H; - readBinaryFile(input_monodepth2_bin[1],dim.tot(),&input_H,&data); - std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); - int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; - for(int i=0;i<4;i++){ - printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); - outs[i]->output_dim.print(); - - dnnType *out, *out_h; - int odim = outs[i]->output_dim.tot(); - readBinaryFile(output_bin[i], odim, &out_h, &out); - - dnnType *cudnn_out, *rt_out; - cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT.buffersRT[i]; - std::cout<<"CUDNN vs correct"; - ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; - std::cout<<"TRT vs correct"; - ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; - std::cout<<"CUDNN vs TRT "; - ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - } - - - return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; - -} \ No newline at end of file -- 2.52.0 From b3bc93693f9113faf70ad8e0a5aca24019c8baa0 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 25 Jan 2022 18:30:39 +0530 Subject: [PATCH 54/58] Revert "Merge branch 'tensorrt8-rds' into depth" This reverts commit 00f06f7bcce2762938499208129f55c669fa295a, reversing changes made to 6a133d8deca8f11de667b208ebaac06feb200e32. --- include/tkDNN/SegmentationNN.h | 241 --------------------------------- 1 file changed, 241 deletions(-) diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index fff27a8..403bc28 100644 --- a/include/tkDNN/SegmentationNN.h +++ b/include/tkDNN/SegmentationNN.h @@ -18,7 +18,6 @@ #include "tkdnn.h" #include "NetworkViz.h" #include "kernelsThrust.h" -#define SLAM_MODE namespace tk { namespace dnn { @@ -100,62 +99,6 @@ class SegmentationNN { * * @param bi batch index */ - - #ifdef SLAM_MODE - cv::Mat postprocess(const int bi=0,bool apply_colormap=true){ - cv::Mat maskMatrix; - dnnType *rt_out = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[1].tot()*bi; - - dataDim_t odim = netRT->output_dim; - - matrixTranspose(cublasHandle, rt_out, tmpInputData_d, odim.c, odim.w*odim.h); - maxElem(tmpInputData_d, tmpOutData_d, odim.c, odim.h, odim.w); - checkCuda(cudaMemcpy(tmpOutData_h, tmpOutData_d, odim.w*odim.h * sizeof(float), cudaMemcpyDeviceToHost)); - - - - dataDim_t vdim = odim; - vdim.c = 1; - dnnType *dataTemp = nullptr; - if(isCudaPointer(tmpOutData_h)) - { - dataTemp = new dnnType[vdim.tot()]; - checkCuda(cudaMemcpy(dataTemp,tmpOutData_h,vdim.tot()*sizeof(dnnType),cudaMemcpyDeviceToHost)); - } - else - { - dataTemp = tmpOutData_h; - } - for(int i =0;iinput_dim.h, netRT->input_dim.w, 0, classes, classes); - else{ - cv::Mat colored_fp32 (cv::Size(odim.w, odim.h),CV_32FC1, dataTemp); - colored_fp32.convertTo(colored, CV_8UC1); - } - - int max_dim = (originalSize[bi].width > originalSize[bi].height) ? originalSize[bi].width : originalSize[bi].height; - resize(colored, colored, cv::Size(max_dim, max_dim)); - int top, bottom, left, right; - computeBorders(originalSize[bi].width, originalSize[bi].height, top, bottom, left, right); - cv::Rect roi(left,top,originalSize[bi].width, originalSize[bi].height); - cv::Mat or_size (colored, roi); - segmented[bi] = or_size; - - if(isCudaPointer(tmpOutData_h)) - { - delete [] dataTemp; - } - - return maskMatrix; - - } - #elif - void postprocess(const int bi=0, bool appy_colormap = true) { dnnType *rt_out = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[1].tot()*bi; @@ -185,7 +128,6 @@ class SegmentationNN { cv::Mat or_size (colored, roi); segmented[bi] = or_size; }; - #endif public: int classes = 0; @@ -295,184 +237,6 @@ class SegmentationNN { } } - #ifdef SLAM_MODE - cv::Mat updateOriginal(cv::Mat frame,bool apply_colormap=true){ - std::vector splitted_frames; - cv::Mat maskMatrix; - int H, W, net_H, net_W; - int top = 0, bottom = 0, left = 0, right = 0; - std::vector> pos; - - { - TKDNN_TSTART - cv::Size original_size = frame.size(); - - frame.convertTo(frame, CV_32FC3, 1 / 255.0, 0); - H = frame.rows; - W = frame.cols; - net_H = netRT->input_dim.h; - net_W = netRT->input_dim.w; - - cv::Mat frame_cropped; - - if( H <= net_H && W <= net_W ){ // smaller size wrt network - top = (net_H - H)/2; - bottom = net_H - H - top ; - left = (net_W - W)/2; - right = net_W - W - left ; - cv::copyMakeBorder(frame, frame_cropped, top, bottom, left, right, cv::BORDER_CONSTANT, cv::Scalar(0,0,0) ); - splitted_frames.push_back(frame_cropped); - } - else{ //bigger size wrt network - - - if(H < net_H || W < net_W){ - if(H < net_H){ - top = (net_H - H)/2; - bottom = net_H - H - top ; - } - else{ - left = (net_W - W)/2; - right = net_W - W - left ; - } - cv::copyMakeBorder(frame, frame_cropped, top, bottom, left, right, cv::BORDER_CONSTANT, cv::Scalar(0,0,0)); - } - - for(int x=0; x+net_W<=W ;){ - for(int y=0; y+net_H <=H ; ){ - cv::Rect roi(x, y, net_W, net_H); - cv::Mat image_roi = frame(roi); - splitted_frames.push_back(image_roi); - pos.push_back(std::make_pair(x,y)); - - y += net_H; - if(y == H) - break; - if(y + net_H > H) y = H - net_H; - } - x += net_W; - if(x == W) - break; - if(x + net_W > W) x = W - net_W; - } - } - - tk::dnn::dataDim_t idim = netRT->input_dim; - - if(splitted_frames.size()> nBatches) - FatalError(std::to_string(splitted_frames.size()) + " min batches required"); - - for(int bi=0; bistream)); - normalize(input_d + idim.tot()*bi, idim.c, idim.h, idim.w, mean_d, stddev_d); - } - TKDNN_TSTOP - stats_pre.push_back(t_ns); - } - - tk::dnn::dataDim_t dim = netRT->input_dim; - dim.n = splitted_frames.size(); - { - if(TKDNN_VERBOSE) dim.print(); - TKDNN_TSTART - netRT->infer(dim, input_d); - TKDNN_TSTOP - if(TKDNN_VERBOSE) dim.print(); - stats.push_back(t_ns); - } - - dataDim_t odim = netRT->output_dim; - - std::vector out_img; - std::vector out_mask; - - { - TKDNN_TSTART - - for(int bi=0; bibuffersRT[1]+ netRT->buffersDIM[1].tot()*bi; - - matrixTranspose(cublasHandle, rt_out, tmpInputData_d, odim.c, odim.w*odim.h); - maxElem(tmpInputData_d, tmpOutData_d, odim.c, odim.h, odim.w); - checkCuda(cudaMemcpy(tmpOutData_h, tmpOutData_d, odim.w*odim.h * sizeof(float), cudaMemcpyDeviceToHost)); - - dataDim_t vdim = odim; - vdim.c = 1; - dnnType *dataTemp = nullptr; - if(isCudaPointer(tmpOutData_h)) - { - dataTemp = new dnnType[vdim.tot()]; - checkCuda(cudaMemcpy(dataTemp,tmpOutData_h,vdim.tot()*sizeof(dnnType),cudaMemcpyDeviceToHost)); - } - else - { - dataTemp = tmpOutData_h; - } - - cv::Mat colored; - for(int i=0;iinput_dim.h, netRT->input_dim.w, 0, classes, classes); - else{ - cv::Mat colored_fp32 (cv::Size(odim.w, odim.h),CV_32FC1, tmpOutData_h); - colored_fp32.convertTo(colored, CV_8UC1); - } - out_img.push_back(colored); - if(isCudaPointer(tmpOutData_h)) - { - delete [] dataTemp; - } - } - - cv::Mat tempMask(frame.size(), out_mask[0].type()); - cv::Mat seg(frame.size(), out_img[0].type()); - if(out_img.size() == 1) - { - cv::Rect roi(left, top, W, H); - seg = out_img[0](roi); - tempMask = out_mask[0](roi); - } - else{ - int bi=0; - - if(top == 0 && left == 0){ - - for(int i=0; i splitted_frames; @@ -621,11 +385,6 @@ class SegmentationNN { stats_post.push_back(t_ns); } } - #endif - - - - /** * Method to draw boundixg boxes and labels on a frame. -- 2.52.0 From 480b5a9c5a6b516fc1d86b9117fe9240b6bb504b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 22 Feb 2022 14:50:39 +0000 Subject: [PATCH 55/58] added monodepth2_1024 --- CMakeLists.txt | 6 +- tests/monodepth2/monodepth2_1024.cpp | 266 ++++++++++++++++++ .../{monodepth2.cpp => monodepth2_640.cpp} | 84 +++--- 3 files changed, 312 insertions(+), 44 deletions(-) create mode 100644 tests/monodepth2/monodepth2_1024.cpp rename tests/monodepth2/{monodepth2.cpp => monodepth2_640.cpp} (82%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7392fd8..1af836d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -204,9 +204,11 @@ add_executable(test_shelfnet_mapillary tests/shelfnet/shelfnet_mapillary.cpp) target_link_libraries(test_shelfnet_mapillary tkDNN) # MONODEPTH2 -add_executable(test_monodepth2 tests/monodepth2/monodepth2.cpp) -target_link_libraries(test_monodepth2 tkDNN) +add_executable(test_monodepth2_640 tests/monodepth2/monodepth2_640.cpp) +target_link_libraries(test_monodepth2_640 tkDNN) +add_executable(test_monodepth2_1024 tests/monodepth2/monodepth2_1024.cpp) +target_link_libraries(test_monodepth2_1024 tkDNN) # DEMOS add_executable(test_rtinference tests/test_rtinference/rtinference.cpp) target_link_libraries(test_rtinference tkDNN) diff --git a/tests/monodepth2/monodepth2_1024.cpp b/tests/monodepth2/monodepth2_1024.cpp new file mode 100644 index 0000000..0dc7c0d --- /dev/null +++ b/tests/monodepth2/monodepth2_1024.cpp @@ -0,0 +1,266 @@ +#include +#include +#include +#include +#include +#include "tkDNN/NetworkViz.h" + +const char* encoder_conv1_bin = "monodepth2_1024/layers/encoder/encoder-conv1.bin"; +const char* encoder_layer1_bin[] = { + "monodepth2_1024/layers/encoder/encoder-layer1-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer1-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer1-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer1-1-conv2.bin", +}; + +const char* encoder_layer2_bin[] = { + "monodepth2_1024/layers/encoder/encoder-layer2-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-0-downsample-0.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer2-1-conv2.bin" +}; + +const char* encoder_layer3_bin[]={ + "monodepth2_1024/layers/encoder/encoder-layer3-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-0-downsample-0.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer3-1-conv2.bin" +}; + +const char* encoder_layer4_bin[] = { + "monodepth2_1024/layers/encoder/encoder-layer4-0-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-0-conv2.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-0-downsample-0.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-1-conv1.bin", + "monodepth2_1024/layers/encoder/encoder-layer4-1-conv2.bin" +}; + +const char *encoder_fc_bin = "monodepth2_1024/layers/encoder/encoder-fc.bin"; + +const char* decoder_layer_bin[] = { + "monodepth2_1024/layers/depth_decoder/decoder-0-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-1-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-2-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-3-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-4-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-5-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-6-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-7-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-8-conv-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-9-conv-conv.bin" +}; + +const char* decoder_dispconv_layer_bin[] = { + "monodepth2_1024/layers/depth_decoder/decoder-10-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-11-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-12-conv.bin", + "monodepth2_1024/layers/depth_decoder/decoder-13-conv.bin" +}; + +const char* output_bin[] = { + "monodepth2_1024/debug/outputs/output-disp-0.bin", + "monodepth2_1024/debug/outputs/output-disp-1.bin", + "monodepth2_1024/debug/outputs/output-disp-2.bin", + "monodepth2_1024/debug/outputs/output-disp-3.bin" +}; + +const char* input_bin = "monodepth2_1024/debug/input.bin"; + + +int main(){ + + //downloadWeightsifDoNotExist(input_bin, "monodepth2_1024", "https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download"); + + tk::dnn::dataDim_t dim(1,3,320,1024,1); + tk::dnn::Network net(dim); + + tk::dnn::Layer* muladd_sub = new tk::dnn::MulAdd(&net, 1.0f, -0.45f); + tk::dnn::Layer* muladd_mul = new tk::dnn::MulAdd(&net, 1.0f / 0.225f, 0.0f); + tk::dnn::Layer* encoder_conv = new tk::dnn::Conv2d(&net,64,7,7,2,2,3,3,encoder_conv1_bin,true); + tk::dnn::Layer* encoder_relu = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_maxpool = new tk::dnn::Pooling(&net,3,3,2,2,1,1,tk::dnn::POOLING_MAX); + + //layer-1 + tk::dnn::Layer* encoder_layer_1_0_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[0],true); + tk::dnn::Layer* encoder_relu_1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_0_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[1],true); + tk::dnn::Layer* encoder_layer_1_0_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_maxpool); + tk::dnn::Layer* encoder_relu_2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[2],true); + tk::dnn::Layer* encoder_relu_3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_1_1_convbn_2 = new tk::dnn::Conv2d(&net,64,3,3,1,1,1,1,encoder_layer1_bin[3],true); + tk::dnn::Layer* encoder_layer_1_1_shortcut_1 = new tk::dnn::Shortcut(&net,encoder_relu_2); + tk::dnn::Layer* encoder_relu_4 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-2 + tk::dnn::Layer* encoder_layer_2_0_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,2,2,1,1,encoder_layer2_bin[0],true); + tk::dnn::Layer* encoder_relu_5 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_0_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[1],true); + tk::dnn::Layer* encoder_layer_2_0_route = new tk::dnn::Route(&net,&encoder_relu_4,1); + tk::dnn::Layer* encoder_layer_2_0_downsample_convbn = new tk::dnn::Conv2d(&net,128,1,1,2,2,0,0,encoder_layer2_bin[2],true); + tk::dnn::Layer* encoder_layer_2_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_2_0_convbn_2); + tk::dnn::Layer* encoder_relu_6 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[3],true); + tk::dnn::Layer* encoder_relu_7 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_2_1_convbn_2 = new tk::dnn::Conv2d(&net,128,3,3,1,1,1,1,encoder_layer2_bin[4],true); + tk::dnn::Layer* encoder_layer_2_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_6); + tk::dnn::Layer* encoder_relu_8 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-3 + tk::dnn::Layer* encoder_layer_3_0_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,2,2,1,1,encoder_layer3_bin[0],true); + tk::dnn::Layer* encoder_relu_9 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_0_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[1],true); + tk::dnn::Layer* encoder_layer_3_0_route = new tk::dnn::Route(&net,&encoder_relu_8,1); + tk::dnn::Layer* encoder_layer_3_0_downsample_convbn = new tk::dnn::Conv2d(&net,256,1,1,2,2,0,0,encoder_layer3_bin[2],true); + tk::dnn::Layer* encoder_layer_3_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_3_0_convbn_2); + tk::dnn::Layer* encoder_relu_10 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[3],true); + tk::dnn::Layer* encoder_relu_11 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_3_1_convbn_2 = new tk::dnn::Conv2d(&net,256,3,3,1,1,1,1,encoder_layer3_bin[4],true); + tk::dnn::Layer* encoder_layer_3_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_10); + tk::dnn::Layer* encoder_relu_12 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //layer-4 + tk::dnn::Layer* encoder_layer_4_0_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,2,2,1,1,encoder_layer4_bin[0],true); + tk::dnn::Layer* encoder_relu_13 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_0_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[1],true); + tk::dnn::Layer* encoder_layer_4_0_route = new tk::dnn::Route(&net,&encoder_relu_12,1); + tk::dnn::Layer* encoder_layer_4_0_downsample_convbn = new tk::dnn::Conv2d(&net,512,1,1,2,2,0,0,encoder_layer4_bin[2],true); + tk::dnn::Layer* encoder_layer_4_0_shortcut = new tk::dnn::Shortcut(&net,encoder_layer_4_0_convbn_2); + tk::dnn::Layer* encoder_relu_14 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_1 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[3],true); + tk::dnn::Layer* encoder_relu_15 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + tk::dnn::Layer* encoder_layer_4_1_convbn_2 = new tk::dnn::Conv2d(&net,512,3,3,1,1,1,1,encoder_layer4_bin[4],true); + tk::dnn::Layer* encoder_layer_4_1shortcut = new tk::dnn::Shortcut(&net,encoder_relu_14); + tk::dnn::Layer* encoder_relu_16 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_RELU); + + //decoder + tk::dnn::Layer* decoder_reflection_padding_2d = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_0 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[0]); + tk::dnn::Layer* decoder_elu = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer[2] = {decoder_upsampling_2d,encoder_relu_12}; + tk::dnn::Layer* decoder_concatenate = new tk::dnn::Route(&net,concatenate_layer,2); + tk::dnn::Layer* decoder_reflection_padding_2d_1 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_4_1 = new tk::dnn::Conv2d(&net,256,3,3,1,1,0,0,decoder_layer_bin[1]); + tk::dnn::Layer* decoder_elu_1 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_2 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_0 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[2]); + tk::dnn::Layer* decoder_elu_2 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_1 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_1[2] = {decoder_upsampling_2d_1,encoder_relu_8}; + tk::dnn::Layer* decoder_concatenate_layer_1 = new tk::dnn::Route{&net,concatenate_layer_1,2}; + tk::dnn::Layer* decoder_reflection_padding_2d_3 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_3_1 = new tk::dnn::Conv2d(&net,128,3,3,1,1,0,0,decoder_layer_bin[3]); + tk::dnn::Layer* decoder_elu_3 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_5 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_0 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[4]); + tk::dnn::Layer* decoder_elu_4 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_2 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_2[2] = {decoder_upsampling_2d_2,encoder_relu_4}; + tk::dnn::Layer* decoder_concatenate_layer_2 = new tk::dnn::Route(&net,concatenate_layer_2,2); + tk::dnn::Layer* decoder_reflection_padding_2d_6 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_2_1 = new tk::dnn::Conv2d(&net,64,3,3,1,1,0,0,decoder_layer_bin[5]); + tk::dnn::Layer* decoder_elu_5 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_8 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_0 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[6]); + tk::dnn::Layer* decoder_elu_6 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_3 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* concatenate_layer_3[2] = {decoder_upsampling_2d_3,encoder_relu}; + tk::dnn::Layer* decoder_concatenate_layer_3 = new tk::dnn::Route(&net,concatenate_layer_3,2); + tk::dnn::Layer* decoder_reflection_padding_2d_9 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_1_1 = new tk::dnn::Conv2d(&net,32,3,3,1,1,0,0,decoder_layer_bin[7]); + tk::dnn::Layer* decoder_elu_7 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_11 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_0 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[8]); + tk::dnn::Layer* decoder_elu_8 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_upsampling_2d_4 = new tk::dnn::Upsample(&net,2); + tk::dnn::Layer* decoder_reflection_padding_2d_12 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_upconv_0_1 = new tk::dnn::Conv2d(&net,16,3,3,1,1,0,0,decoder_layer_bin[9]); + tk::dnn::Layer* decoder_elu_9 = new tk::dnn::Activation(&net,tk::dnn::ACTIVATION_ELU); + tk::dnn::Layer* decoder_reflection_padding_2d_13 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_0 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[0]); + tk::dnn::Layer* disp0 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp0->setFinal(); + + tk::dnn::Layer* route_elu_7 = new tk::dnn::Route(&net,&decoder_elu_7,1); + tk::dnn::Layer* decoder_reflection_padding_2d_10 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_1 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[1]); + tk::dnn::Layer* disp1 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp1->setFinal(); + + tk::dnn::Layer* route_elu_5 = new tk::dnn::Route(&net,&decoder_elu_5,1); + tk::dnn::Layer* decoder_reflection_padding_2d_7 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_2 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[2]); + tk::dnn::Layer* disp2 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp2->setFinal(); + + tk::dnn::Layer* route_elu_3 = new tk::dnn::Route(&net,&decoder_elu_3,1); + tk::dnn::Layer* decoder_reflection_padding_2d_4 = new tk::dnn::Padding(&net,1,1,tk::dnn::PADDING_MODE_REFLECTION); + tk::dnn::Layer* decoder_dispconv_3 = new tk::dnn::Conv2d(&net,1,3,3,1,1,0,0,decoder_dispconv_layer_bin[3]); + tk::dnn::Layer* disp3 = new tk::dnn::Activation(&net,CUDNN_ACTIVATION_SIGMOID); + disp3->setFinal(); + + + dnnType *data; + dnnType *input_H; + readBinaryFile(input_bin, dim.tot(),&input_H,&data); + std::cout<<"INPUT DIMENSIONS : "<output_dim.print(); + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + for(int i=0;i<4;i++){ + printCenteredTitle((std::string("MONODEPTH2 CHECK RESULTS ") + std::to_string(i) + " ").c_str(), '=', 30); + outs[i]->output_dim.print(); + + dnnType *out, *out_h; + int odim = outs[i]->output_dim.tot(); + readBinaryFile(output_bin[i], odim, &out_h, &out); + + dnnType *cudnn_out, *rt_out; + cudnn_out = outs[i]->dstData; + rt_out = (dnnType *)netRT.buffersRT[1+i]; + std::cout<<"CUDNN vs correct"; + ret_cudnn |= checkResult(odim, cudnn_out, out) == 0 ? 0: ERROR_CUDNN; + std::cout<<"TRT vs correct"; + ret_tensorrt |= checkResult(odim, rt_out, out) == 0 ? 0 : ERROR_TENSORRT; + std::cout<<"CUDNN vs TRT "; + ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + + cv::Mat depth_mat = vizData2Mat(outs[i]->dstData, outs[i]->output_dim, outs[i]->output_dim.h, outs[i]->output_dim.w); + cv::imshow("depth", depth_mat); + cv::waitKey(0); + } + + + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; + + +} \ No newline at end of file diff --git a/tests/monodepth2/monodepth2.cpp b/tests/monodepth2/monodepth2_640.cpp similarity index 82% rename from tests/monodepth2/monodepth2.cpp rename to tests/monodepth2/monodepth2_640.cpp index 8618539..378c735 100644 --- a/tests/monodepth2/monodepth2.cpp +++ b/tests/monodepth2/monodepth2_640.cpp @@ -5,73 +5,73 @@ #include #include "tkDNN/NetworkViz.h" -const char* encoder_conv1_bin = "monodepth2/layers/encoder/encoder-conv1.bin"; +const char* encoder_conv1_bin = "monodepth2_640/layers/encoder/encoder-conv1.bin"; const char* encoder_layer1_bin[] = { - "monodepth2/layers/encoder/encoder-layer1-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer1-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer1-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer1-1-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer1-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer1-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer1-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer1-1-conv2.bin", }; const char* encoder_layer2_bin[] = { - "monodepth2/layers/encoder/encoder-layer2-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer2-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer2-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer2-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer2-1-conv2.bin" + "monodepth2_640/layers/encoder/encoder-layer2-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer2-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer2-0-downsample-0.bin", + "monodepth2_640/layers/encoder/encoder-layer2-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer2-1-conv2.bin" }; const char* encoder_layer3_bin[]={ - "monodepth2/layers/encoder/encoder-layer3-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer3-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer3-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer3-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer3-1-conv2.bin" + "monodepth2_640/layers/encoder/encoder-layer3-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer3-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer3-0-downsample-0.bin", + "monodepth2_640/layers/encoder/encoder-layer3-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer3-1-conv2.bin" }; const char* encoder_layer4_bin[] = { - "monodepth2/layers/encoder/encoder-layer4-0-conv1.bin", - "monodepth2/layers/encoder/encoder-layer4-0-conv2.bin", - "monodepth2/layers/encoder/encoder-layer4-0-downsample-0.bin", - "monodepth2/layers/encoder/encoder-layer4-1-conv1.bin", - "monodepth2/layers/encoder/encoder-layer4-1-conv2.bin" + "monodepth2_640/layers/encoder/encoder-layer4-0-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer4-0-conv2.bin", + "monodepth2_640/layers/encoder/encoder-layer4-0-downsample-0.bin", + "monodepth2_640/layers/encoder/encoder-layer4-1-conv1.bin", + "monodepth2_640/layers/encoder/encoder-layer4-1-conv2.bin" }; -const char *encoder_fc_bin = "monodepth2/layers/encoder/encoder-fc.bin"; +const char *encoder_fc_bin = "monodepth2_640/layers/encoder/encoder-fc.bin"; const char* decoder_layer_bin[] = { - "monodepth2/layers/depth_decoder/decoder-0-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-1-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-2-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-3-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-4-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-5-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-6-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-7-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-8-conv-conv.bin", - "monodepth2/layers/depth_decoder/decoder-9-conv-conv.bin" + "monodepth2_640/layers/depth_decoder/decoder-0-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-1-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-2-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-3-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-4-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-5-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-6-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-7-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-8-conv-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-9-conv-conv.bin" }; const char* decoder_dispconv_layer_bin[] = { - "monodepth2/layers/depth_decoder/decoder-10-conv.bin", - "monodepth2/layers/depth_decoder/decoder-11-conv.bin", - "monodepth2/layers/depth_decoder/decoder-12-conv.bin", - "monodepth2/layers/depth_decoder/decoder-13-conv.bin" + "monodepth2_640/layers/depth_decoder/decoder-10-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-11-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-12-conv.bin", + "monodepth2_640/layers/depth_decoder/decoder-13-conv.bin" }; const char* output_bin[] = { - "monodepth2/debug/outputs/output-disp-0.bin", - "monodepth2/debug/outputs/output-disp-1.bin", - "monodepth2/debug/outputs/output-disp-2.bin", - "monodepth2/debug/outputs/output-disp-3.bin" + "monodepth2_640/debug/outputs/output-disp-0.bin", + "monodepth2_640/debug/outputs/output-disp-1.bin", + "monodepth2_640/debug/outputs/output-disp-2.bin", + "monodepth2_640/debug/outputs/output-disp-3.bin" }; -const char* input_bin = "monodepth2/debug/input.bin"; +const char* input_bin = "monodepth2_640/debug/input.bin"; int main(){ - downloadWeightsifDoNotExist(input_bin, "monodepth2", "https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download"); + downloadWeightsifDoNotExist(input_bin, "monodepth2_640", "https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download"); tk::dnn::dataDim_t dim(1,3,192,640,1); tk::dnn::Network net(dim); @@ -211,7 +211,7 @@ int main(){ net.print(); - tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("monodepth2")); + tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("monodepth2_640")); tk::dnn::dataDim_t dim1 = dim; dnnType *cudnn_out = nullptr; printCenteredTitle(" CUDNN inference ", '=', 30); -- 2.52.0 From 40266a6c324be861da878984e32ef8b42b58cd55 Mon Sep 17 00:00:00 2001 From: Harshvardhan Chandirasekar <43143075+perseusdg@users.noreply.github.com> Date: Wed, 16 Mar 2022 18:09:32 +0530 Subject: [PATCH 56/58] Fixed tensorrt8 branch to work jetpack 4.5 and tensorrt7 Signed-off-by: perseusdg --- include/tkDNN/NetworkRT.h | 2 +- src/NetworkRT.cpp | 9 ++++++++- src/pluginsRT/ConstantPaddingRT.cpp | 13 ++++++++----- 3 files changed, 17 insertions(+), 7 deletions(-) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 6457068..a7e67c2 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -95,7 +95,7 @@ public: nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Region *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Shortcut *l); nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Yolo *l); - nvinfer1::IResizeLayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); + nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input,Padding *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor* input,MulAdd *l); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 9177ef2..c7427d1 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -834,7 +834,7 @@ IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { return lRT; } -IResizeLayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { +ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { #if NV_TENSORRT_MAJOR < 8 auto creator = getPluginRegistry()->getPluginCreator("UpSample_tkDNN","1"); @@ -1008,6 +1008,7 @@ bool NetworkRT::deserialize(const char *filename) { return true; } +#if NV_TENSORRT_MAJOR > 7 void NetworkRT::destroy() { delete contextRT; if(builderActive) { @@ -1015,5 +1016,11 @@ void NetworkRT::destroy() { delete builderRT; } } +#elif NV_TENSORRT_MAJOR <=7 +void NetworkRT::destroy() { + +} +#endif + }} diff --git a/src/pluginsRT/ConstantPaddingRT.cpp b/src/pluginsRT/ConstantPaddingRT.cpp index ac37e9d..546aa7e 100644 --- a/src/pluginsRT/ConstantPaddingRT.cpp +++ b/src/pluginsRT/ConstantPaddingRT.cpp @@ -66,11 +66,12 @@ int ConstantPaddingRT::enqueue(int batchSize, const void *const *inputs, void *c return 0; } #elif NV_TENSORRT_MAJOR <= 7 - int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { - dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType* dstData = reinterpret_cast(outputs[0]); - constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); - return 0; +int32_t ConstantPaddingRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType* srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType* dstData = reinterpret_cast(outputs[0]); + constant_pad2d_forward(srcData,dstData,i_h,i_w,o_h,o_w,c,n,padH,padW,constant,stream); + return 0; } #endif @@ -151,6 +152,8 @@ bool ConstantPaddingRT::supportsFormat(DataType type, PluginFormat format) const return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } + + ConstantPaddingRTPluginCreator::ConstantPaddingRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); -- 2.52.0 From c690d537f1802aadbad34bafe1563712b16fe82b Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Wed, 30 Mar 2022 15:40:25 +0200 Subject: [PATCH 57/58] Update READMEs, add README_depth, minors Signed-off-by: Micaela Verucchi --- README.md | 16 +++++++++++- demo/demo/demoDepth.cpp | 2 +- docs/README_depth.md | 54 +++++++++++++++++++++++++++++++++++++++ docs/exporting_weights.md | 12 +++++++++ 4 files changed, 82 insertions(+), 2 deletions(-) create mode 100644 docs/README_depth.md diff --git a/README.md b/README.md index af7c9c5..fa00681 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,10 @@ If you use tkDNN in your research, please cite the [following paper](https://iee - [x] Support 2D/3D Object Detection and Tracking [README](docs/README_2d3dtracking.md) #### 24 November 2021 - [x] Support to sematic segmentation on cuda 11 -- [x] Support to TensorRT8. +- [x] Support to TensorRT8 (tensort8 branch). + +#### 30 March 2022 +- [x] Support to monocular depth esitmation (tensort8 branch) [README](docs/README_depth.md) TensorRT8 (and therefore Jetpack 4.6) is currently supported only on the branch tensort8 due to [performance issue with TensorRT8](https://docs.nvidia.com/deeplearning/tensorrt/release-notes/tensorrt-8.html)). We will merge it to the master as soon as those issues are fixed (probably in future minor releases). @@ -138,6 +141,7 @@ For specific details on how to export weights see [HERE](./docs/exporting_weight For specific details on how to run: - 2D object detection demos, details on FP16, INT8 and batching see [HERE](./docs/demo.md). - segmentation demos see [HERE](./docs/README_seg.md). +- monocular depth estimation see [HERE](./docs/README_depth.md). - 2D/3D object detection and tracking demos see [HERE](./docs/README_2d3dtracking.md). - mAP demo to evaluate 2D object detectors see [HERE](./docs/mAP_demo.md). @@ -185,6 +189,8 @@ For specific details on how to run tkDNN on Windows 10/11 see [HERE](./docs/wind | shelfnet_berkeley | ShelfNet18_realtime11 | [DeepDrive](https://bdd-data.berkeley.edu/) | 20 | 1024x1024 | [weights](https://cloud.hipert.unimore.it/s/m92e7QdD9gYMF7f/download) | | dla34_cnet3d | Centernet3D (DLA34 backend)4 | [KITTI 2017](http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d) | 1 | 512x512 | [weights](https://cloud.hipert.unimore.it/s/2MDyWGzQsTKMjmR/download) | | dla34_ctrack | CenterTrack (DLA34 backend)12 | [NuScenes 3D](https://www.nuscenes.org/) | 7 | 512x512 | [weights](https://cloud.hipert.unimore.it/s/rjNfgGL9FtAXLHp/download) | +| monodepth2 | Monodepth2 13 | [KITTI DEPTH](http://www.cvlibs.net/datasets/kitti/raw_data.php) | - | 640x192 | [weights-mono](https://cloud.hipert.unimore.it/s/iYw9QwgP6CsqxLR/download) | +| monodepth2 | Monodepth2 13 | [KITTI DEPTH](http://www.cvlibs.net/datasets/kitti/raw_data.php) | - | 640x192 | [weights-stereo](https://cloud.hipert.unimore.it/s/XmwbWNXDfqyQ4EL/download) | ## References @@ -201,3 +207,11 @@ For specific details on how to run tkDNN on Windows 10/11 see [HERE](./docs/wind 10. Wang, Chien-Yao, Alexey Bochkovskiy, and Hong-Yuan Mark Liao. "Scaled-YOLOv4: Scaling Cross Stage Partial Network." arXiv preprint arXiv:2011.08036 (2020). 11. Zhuang, Juntang, et al. "ShelfNet for fast semantic segmentation." Proceedings of the IEEE International Conference on Computer Vision Workshops. 2019. 12. Zhou, Xingyi, Vladlen Koltun, and Philipp Krähenbühl. "Tracking objects as points." European Conference on Computer Vision. Springer, Cham, 2020. +13. Godard, Clément, et al. "Digging into self-supervised monocular depth estimation." Proceedings of the IEEE/CVF International Conference on Computer Vision. 2019. + +## Contributors +The main contibutors, in chronological order, are: +- [Francesco Gatti](https://github.com/ceccocats), francesco.gatti@hipert.it +- [Micaela Verucchi](https://github.com/mive93), micaela.verucchi@unimore.it +- [Davide Sapienza](https://github.com/sapienzadavide), davide.sapienza@unimore.it +- [Harshvardhan Chandirasekar](https://github.com/perseusdg), f20180523@goa.bits-pilani.ac.in diff --git a/demo/demo/demoDepth.cpp b/demo/demo/demoDepth.cpp index 41f5dbf..6c7de82 100644 --- a/demo/demo/demoDepth.cpp +++ b/demo/demo/demoDepth.cpp @@ -57,7 +57,7 @@ int main(int argc, char *argv[]) { if(save) { int w = depthNN.output_w; int h = depthNN.output_h; - resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','J','P','G'), 30, cv::Size(w, h)); + resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','P','4','V'), 30, cv::Size(w, h)); } if(show) diff --git a/docs/README_depth.md b/docs/README_depth.md new file mode 100644 index 0000000..ac87bb6 --- /dev/null +++ b/docs/README_depth.md @@ -0,0 +1,54 @@ +# Monocular depth estimation with tkDNN + +Currently tkDNN supports only Monodepth2 as monocular depth esitmation network. + + +## Run the demo + +To run the depth estimation demo follow these steps (example with monodepth2): +``` +rm monodepth2_fp32.rt # be sure to delete(or move) old tensorRT files +./test_monodepth2 # run the yolo test (is slow) +./demoDepth monodepth2_fp32.rt ../demo/yolo_test.mp4 +``` +In general the demo program takes the following parameters: +``` +./demoDepth +``` +where +* `````` is the rt file generated by a test +* ```<``` is the path to a video file or a camera input +* `````` if set to 0 the demo will not show the visualization, it will otherwise (default=1) +* `````` if set to 1 the demo will save the video into result.mp4, it won't otherwise (default=1) + +NB) By default it is used FP32 inference + + +![demo](https://user-images.githubusercontent.com/11939259/160845358-0d6ab15d-c5f4-46ae-b9da-bfaf3903389d.gif "Results on yolo_test.mp4") + + + + diff --git a/docs/exporting_weights.md b/docs/exporting_weights.md index 811431d..b4cb366 100644 --- a/docs/exporting_weights.md +++ b/docs/exporting_weights.md @@ -86,6 +86,18 @@ mkdir layer debug python export.py ``` +### 6)Export weights for monodepth2 +To get the weights needed to run Shelfnet tests use [this](https://github.com/perseusdg/monodepth2) fork of a Pytorch implementation of monodepth2 network. + +``` +git clone https://github.com/perseusdg/monodepth2 +cd monodepth2 +mkdir models # Download the official weights and put depth.pth and encorder.pth inside this new folder +conda env create --file monodepth.yaml +conda activate monodepth2 +python exporter.py # you will find the weights inside the tkDNN_bin folder +``` + ## Darknet Parser tkDNN implement and easy parser for darknet cfg files, a network can be converted with *tk::dnn::darknetParser*: ``` -- 2.52.0 From 69bb7370a5ce747faa3e22aff3f1896aa8a8d802 Mon Sep 17 00:00:00 2001 From: Francesco Gatti Date: Wed, 30 Mar 2022 15:52:30 +0200 Subject: [PATCH 58/58] compile with tensorrt7 --- CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1af836d..13db7b5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -78,8 +78,7 @@ endif() #------------------------------------------------------------------------------- # CUDA #------------------------------------------------------------------------------- - -#set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") +set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}" --compiler-options '-fPIC') find_package(CUDNN REQUIRED) -- 2.52.0