mmr/tkDNN
Archived
1
0
Fork 0
Code Issues 46 Pull Requests 12 Releases 4 Activity

cudnn5 branch for tx2

Browse Source
This commit is contained in:
Francesco Gatti
2017-07-14 11:11:51 +02:00
parent 33513468e6
commit e4df86a07c
9 changed files with 49 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Activation.cpp
+19 -17
View File
@@ -5,7 +5,7 @@
namespace tkDNN {
Activation::Activation(Network *net, dataDim_t input_dim, tkdnnActivationMode_t act_mode) :
Activation::Activation(Network *net, dataDim_t input_dim, cudnnActivationMode_t act_mode) :
Layer(net, input_dim) {
this->act_mode = act_mode;
@@ -23,6 +23,13 @@ Activation::Activation(Network *net, dataDim_t input_dim, tkdnnActivationMode_t
input_dim.n*input_dim.l,
input_dim.c,
input_dim.h, input_dim.w) );
checkCUDNN( cudnnCreateActivationDescriptor(&activDesc) );
checkCUDNN( cudnnSetActivationDescriptor(activDesc,
act_mode,
CUDNN_PROPAGATE_NAN,
0.0) );
}
Activation::~Activation() {
@@ -32,22 +39,17 @@ Activation::~Activation() {
value_type* Activation::infer(dataDim_t &dim, value_type* srcData) {
if(act_mode == ACTIVATION_ELU) {
activationELUForward(srcData, dstData, dim.tot());
} else {
value_type alpha = value_type(1);
value_type beta = value_type(0);
checkCUDNN( cudnnActivationForward(net->cudnnHandle,
cudnnActivationMode_t(act_mode),
&alpha,
srcTensorDesc,
srcData,
&beta,
dstTensorDesc,
dstData) );
}
value_type alpha = value_type(1);
value_type beta = value_type(0);
checkCUDNN( cudnnActivationForward(net->cudnnHandle,
activDesc,
&alpha,
srcTensorDesc,
srcData,
&beta,
dstTensorDesc,
dstData) );
return dstData;
}
}
}
src/Conv2d.cpp
+3 -3
View File
@@ -29,7 +29,7 @@ Conv2d::Conv2d( Network *net, dataDim_t in_dim, int out_ch,
net->tensorFormat, net->dataType, n, c, h, w) );
checkCUDNN( cudnnSetFilter4dDescriptor(filterDesc,
net->dataType, out_ch, input_dim.c,
net->dataType, net->tensorFormat, out_ch, input_dim.c,
kernelH, kernelW) );
checkCUDNN( cudnnSetConvolution2dDescriptor(convDesc,
@@ -103,7 +103,7 @@ value_type* Conv2d::infer(dataDim_t &dim, value_type* srcData) {
// bias
alpha = value_type(1);
beta = value_type(1);
checkCUDNN( cudnnAddTensor(net->cudnnHandle, CUDNN_ADD_SAME_C,
checkCUDNN( cudnnAddTensor(net->cudnnHandle,
&alpha, biasTensorDesc, bias_d,
&beta, dstTensorDesc, dstData) );
@@ -113,4 +113,4 @@ value_type* Conv2d::infer(dataDim_t &dim, value_type* srcData) {
return dstData;
}
}
}
src/Conv3d.cpp
-157
View File
@@ -1,157 +0,0 @@
#include <iostream>
#include "Layer.h"
namespace tkDNN {
Conv3d::Conv3d( Network *net, dataDim_t in_dim, int out_ch,
int kernelH, int kernelW, int kernelL,
int strideH, int strideW, int strideL,
const char* fname_weights, const char* fname_bias) :
LayerWgs(net, in_dim, in_dim.c, out_ch, kernelH, kernelW, kernelL,
fname_weights, fname_bias) {
this->kernelH = kernelH;
this->kernelW = kernelW;
this->kernelL = kernelL;
this->strideH = strideH;
this->strideW = strideW;
this->strideL = strideL;
checkCUDNN( cudnnCreateTensorDescriptor(&biasDstTensorDesc) );
checkCUDNN( cudnnCreateFilterDescriptor(&filterDesc) );
checkCUDNN( cudnnCreateConvolutionDescriptor(&convDesc) );
checkCUDNN( cudnnCreateTensorDescriptor(&biasTensorDesc) );
int n = input_dim.n;
int c = input_dim.c;
int h = input_dim.h;
int w = input_dim.w;
int l = input_dim.l;
//create a tensor Nd descriptor with N = 4
int dimA[5];
dimA[0] = n; dimA[1] = c; dimA[2] = h; dimA[3] = w; dimA[4] = l;
int strideA[5];
strideA[0] = c*h*w*l;
strideA[1] = h*w*l;
strideA[2] = w*l;
strideA[3] = l;
strideA[4] = 1;
checkCUDNN( cudnnSetTensorNdDescriptor(srcTensorDesc,
net->dataType, 5, dimA, strideA));
//filter descriptor
int filterDim[5];
filterDim[0] = out_ch;
filterDim[1] = in_dim.c;
filterDim[2] = kernelH;
filterDim[3] = kernelW;
filterDim[4] = kernelL;
checkCUDNN( cudnnSetFilterNdDescriptor(filterDesc,
net->dataType, 5, filterDim));
//convolutional descriptor
int padA[3] = {0, 0, 0};
int filterStride[3] = {strideH, strideW, strideL};
int upscale[3] = {1, 1, 1};
checkCUDNN( cudnnSetConvolutionNdDescriptor(convDesc, 3,
padA, filterStride, upscale, CUDNN_CROSS_CORRELATION));
//get output dimension
int outputDim[5];
checkCUDNN(cudnnGetConvolutionNdForwardOutputDim(convDesc, srcTensorDesc, filterDesc, 5, outputDim));
n = outputDim[0];
c = outputDim[1];
h = outputDim[2];
w = outputDim[3];
l = outputDim[4];
//destination sensor
int outputStride[5];
outputStride[0] = c*h*w*l;
outputStride[1] = h*w*l;
outputStride[2] = w*l;
outputStride[3] = l;
outputStride[4] = 1;
checkCUDNN( cudnnSetTensorNdDescriptor(dstTensorDesc, net->dataType,
5, outputDim, outputStride));
//conv algo
checkCUDNN( cudnnGetConvolutionForwardAlgorithm(net->cudnnHandle,
srcTensorDesc, filterDesc, convDesc, dstTensorDesc,
CUDNN_CONVOLUTION_FWD_PREFER_FASTEST, 0, &algo) );
checkCUDNN( cudnnGetConvolutionForwardWorkspaceSize(net->cudnnHandle,
srcTensorDesc,
filterDesc,
convDesc,
dstTensorDesc,
algo,
&ws_sizeInBytes) );
if (ws_sizeInBytes!=0)
checkCuda( cudaMalloc(&workSpace, ws_sizeInBytes) );
// bias on N dimensional is not SUPPORTED so i have to use 2d method
//the trick is to upscale the 2d matrix width by the factor of 3d thickness
checkCUDNN( cudnnSetTensor4dDescriptor(biasDstTensorDesc,
net->tensorFormat, net->dataType, n, c, h*l, w) );
checkCUDNN( cudnnSetTensor4dDescriptor(biasTensorDesc,
net->tensorFormat, net->dataType,
1, c, 1, 1) );
output_dim.n = n;
output_dim.c = c;
output_dim.h = h;
output_dim.w = w;
output_dim.l = l;
//allocate data for infer result
checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(value_type)) );
}
Conv3d::~Conv3d() {
checkCUDNN( cudnnDestroyFilterDescriptor(filterDesc) );
checkCUDNN( cudnnDestroyConvolutionDescriptor(convDesc) );
checkCUDNN( cudnnDestroyTensorDescriptor(biasTensorDesc) );
checkCUDNN( cudnnDestroyTensorDescriptor(biasDstTensorDesc) );
if (ws_sizeInBytes!=0)
checkCuda( cudaFree(workSpace) );
checkCuda( cudaFree(dstData) );
}
value_type* Conv3d::infer(dataDim_t &dim, value_type* srcData) {
// convolution
value_type alpha = value_type(1);
value_type beta = value_type(0);
checkCUDNN( cudnnConvolutionForward(net->cudnnHandle,
&alpha, srcTensorDesc, srcData, filterDesc,
data_d, convDesc, algo, workSpace, ws_sizeInBytes,
&beta, dstTensorDesc, dstData) );
// bias
alpha = value_type(1);
beta = value_type(1);
checkCUDNN( cudnnAddTensor(net->cudnnHandle, CUDNN_ADD_SAME_C,
&alpha, biasTensorDesc, bias_d,
&beta, biasDstTensorDesc, dstData) );
//update data dimensions
dim = output_dim;
return dstData;
}
}
src/Dense.cpp
+1 -1
View File
@@ -56,4 +56,4 @@ value_type* Dense::infer(dataDim_t &dim, value_type* srcData) {
return dstData;
}
}
}
src/Pooling.cpp
+2 -2
View File
@@ -40,7 +40,7 @@ Pooling::Pooling( Network *net, dataDim_t input_dim,
}
checkCUDNN( cudnnSetPooling2dDescriptor(poolingDesc, cudnnPoolingMode_t(pool_mode),
winH, winW, 0, 0, strideH, strideW) );
CUDNN_NOT_PROPAGATE_NAN, winH, winW, 0, 0, strideH, strideW) );
checkCUDNN( cudnnSetTensor4dDescriptor(srcTensorDesc,
net->tensorFormat, net->dataType, n, c, h, w) );
@@ -108,4 +108,4 @@ value_type* Pooling::infer(dataDim_t &dim, value_type* srcData) {
return dstData;
}
}
}