Moved batchnorm and test_monodepth2_new_format layer to dev
Signed-off-by: perseusdg <harshvardhan.chandira@gmail.com>
This commit is contained in:
Harshvardhan Chandirasekar
committed by
perseusdg
perseusdg
parent
00f06f7bcc
commit
afdad8e661
@@ -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)
|
||||
|
||||
@@ -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
|
||||
*/
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
#include <iostream>
|
||||
|
||||
#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) );
|
||||
}
|
||||
|
||||
}}
|
||||
@@ -1,88 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
|
||||
#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();
|
||||
}
|
||||
|
||||
} }
|
||||
@@ -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;
|
||||
|
||||
@@ -1,306 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <opencv2/imgproc/imgproc.hpp>
|
||||
#include <opencv2/highgui/highgui.hpp>
|
||||
#include <tkdnn.h>
|
||||
|
||||
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 : "<<dim.tot()<<std::endl;
|
||||
|
||||
net.print();
|
||||
|
||||
tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("monodepth2"));
|
||||
tk::dnn::dataDim_t dim1 = dim;
|
||||
dnnType *cudnn_out = nullptr;
|
||||
printCenteredTitle(" CUDNN inference ", '=', 30);
|
||||
{
|
||||
dim1.print();
|
||||
TKDNN_TSTART
|
||||
net.infer(dim1, data);
|
||||
TKDNN_TSTOP
|
||||
dim1.print();
|
||||
}
|
||||
|
||||
tk::dnn::dataDim_t dim2 = dim;
|
||||
printCenteredTitle(" TENSORRT inference ", '=', 30);
|
||||
{
|
||||
dim2.print();
|
||||
TKDNN_TSTART
|
||||
netRT.infer(dim2, data);
|
||||
TKDNN_TSTOP
|
||||
dim2.print();
|
||||
}
|
||||
tk::dnn::Layer *outs[4] = {disp0,disp1,disp2,disp3};
|
||||
std::cout<<std::endl<<std::endl;
|
||||
disp3->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;
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user