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

Moved batchnorm and test_monodepth2_new_format layer to dev

Browse Source 
Signed-off-by: perseusdg <harshvardhan.chandira@gmail.com>
This commit is contained in:
Harshvardhan Chandirasekar
2022-01-24 21:41:59 +05:30
committed by perseusdg
parent 00f06f7bcc
commit 3e86671c50
5 changed files with 0 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/BatchNorm.cpp
-67
View File
@@ -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) );
}
}}
src/LayerBNWgs.cpp
-88
View File
@@ -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();
}
} }