mirror of
https://github.com/opencv/opencv.git
synced 2026-07-27 14:23:04 +04:00
Li Peng
5992c46606
The ocl convolution doesn't support tensorflow padMode well. Add fallback check if we meet this situation, it could fix the tensorflow MobileNet SSD failure. Signed-off-by: Li Peng <peng.li@intel.com>
1674 lines
67 KiB
C++
1674 lines
67 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
|
|
// Copyright (C) 2017, Intel Corporation, all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
#include "../precomp.hpp"
|
|
#include "layers_common.hpp"
|
|
#include "op_halide.hpp"
|
|
#include "op_inf_engine.hpp"
|
|
#include "opencv2/core/hal/hal.hpp"
|
|
#include "opencv2/core/hal/intrin.hpp"
|
|
#include <iostream>
|
|
#include "opencl_kernels_dnn.hpp"
|
|
|
|
#ifdef HAVE_OPENCL
|
|
using namespace cv::dnn::ocl4dnn;
|
|
#endif
|
|
|
|
namespace cv
|
|
{
|
|
namespace dnn
|
|
{
|
|
|
|
class BaseConvolutionLayerImpl : public ConvolutionLayer
|
|
{
|
|
public:
|
|
BaseConvolutionLayerImpl() {}
|
|
|
|
virtual bool supportBackend(int backendId)
|
|
{
|
|
return backendId == DNN_BACKEND_DEFAULT ||
|
|
backendId == DNN_BACKEND_HALIDE && haveHalide() ||
|
|
backendId == DNN_BACKEND_INFERENCE_ENGINE && haveInfEngine();
|
|
}
|
|
|
|
void finalize(const std::vector<Mat*> &inputs, std::vector<Mat> &outputs)
|
|
{
|
|
CV_Assert(inputs.size() > 0);
|
|
|
|
CV_Assert(blobs.size() >= 1 && blobs.size() <= 2);
|
|
CV_Assert(blobs[0].dims == 4 && blobs[0].size[3] == kernel.width && blobs[0].size[2] == kernel.height);
|
|
|
|
const Mat &input = *inputs[0];
|
|
CV_Assert(input.dims == 4 && (input.type() == CV_32F || input.type() == CV_64F));
|
|
for (size_t i = 0; i < inputs.size(); i++)
|
|
{
|
|
CV_Assert(inputs[i]->type() == input.type());
|
|
CV_Assert(inputs[i]->dims == 4 && inputs[i]->size[1] == input.size[1]);
|
|
CV_Assert(inputs[i]->size[2] == input.size[2] && inputs[i]->size[3] == input.size[3]);
|
|
}
|
|
|
|
Size outSize = Size(outputs[0].size[3], outputs[0].size[2]);
|
|
getConvPoolPaddings(Size(input.size[3], input.size[2]), outSize,
|
|
kernel, stride, padMode, dilation, pad);
|
|
}
|
|
|
|
bool hasBias() const
|
|
{
|
|
return blobs.size() >= 2;
|
|
}
|
|
|
|
virtual MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const = 0;
|
|
bool is1x1() const
|
|
{
|
|
return (kernel.height == 1 && kernel.width == 1) &&
|
|
(stride.height == 1 && stride.width == 1) &&
|
|
(dilation.height == 1 && dilation.width == 1);
|
|
}
|
|
|
|
virtual void applyHalideScheduler(Ptr<BackendNode>& node,
|
|
const std::vector<Mat*> &inputs,
|
|
const std::vector<Mat> &outputs,
|
|
int targetId) const
|
|
{
|
|
#ifdef HAVE_HALIDE
|
|
if (targetId != DNN_TARGET_CPU)
|
|
{
|
|
Layer::applyHalideScheduler(node, inputs, outputs, targetId);
|
|
return;
|
|
}
|
|
Halide::Var x("x"), y("y"), c("c"), n("n"), tile("tile"), yi("yi"), yo("yo"), co("co"), ci("ci");
|
|
Halide::Func& top = node.dynamicCast<HalideBackendNode>()->funcs[1];
|
|
Halide::Func& padded_input = node.dynamicCast<HalideBackendNode>()->funcs[0];
|
|
|
|
int outW, outH, outC, outN;
|
|
getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN);
|
|
|
|
if (outW == 1 || outH <= 2)
|
|
return;
|
|
|
|
if (is1x1() || outC <= 16)
|
|
top.reorder(x, c, y)
|
|
.split(y, yo, yi, 2)
|
|
.fuse(yo, n, tile)
|
|
.parallel(tile)
|
|
.unroll(yi)
|
|
.vectorize(x, outW >= 16 ? 16 : outW);
|
|
else
|
|
top.reorder(x, c, y)
|
|
.split(y, yo, yi, 2)
|
|
.split(c, co, ci, 16)
|
|
.fuse(yo, co, tile).fuse(n, tile, tile)
|
|
.parallel(tile)
|
|
.unroll(yi)
|
|
.vectorize(x, outW >= 16 ? 16 : outW);
|
|
padded_input.compute_at(top, yi);
|
|
#endif // HAVE_HALIDE
|
|
}
|
|
};
|
|
|
|
|
|
#define IS_POWER_LAYER(layer) \
|
|
(!layer.empty() && !layer->type.compare("Power"))
|
|
//TODO: simultaneously convolution and bias addition for cache optimization
|
|
class ConvolutionLayerImpl : public BaseConvolutionLayerImpl
|
|
{
|
|
public:
|
|
enum { VEC_ALIGN = 8, DFT_TYPE = CV_32F };
|
|
Mat weightsMat;
|
|
std::vector<float> biasvec;
|
|
std::vector<float> reluslope;
|
|
Ptr<ActivationLayer> activ;
|
|
Ptr<BatchNormLayer> bnorm;
|
|
Ptr<ScaleLayer> scaleLayer;
|
|
|
|
#ifdef HAVE_OPENCL
|
|
Ptr<OCL4DNNConvSpatial<float> > convolutionOp;
|
|
std::vector<UMat> umat_blobs;
|
|
bool fusedBias;
|
|
bool newWeightAndBias;
|
|
bool newActiv;
|
|
ocl4dnnFusedActiv_t activType;
|
|
float power;
|
|
#endif
|
|
ConvolutionLayerImpl()
|
|
{
|
|
#ifdef HAVE_OPENCL
|
|
fusedBias = false;
|
|
newWeightAndBias = false;
|
|
newActiv = false;
|
|
activType = OCL4DNN_CONV_FUSED_ACTIV_NONE;
|
|
power = 0.f;
|
|
#endif
|
|
}
|
|
|
|
MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const
|
|
{
|
|
Size out(outShape[3], outShape[2]);
|
|
int inpGroupCn = blobs[0].size[1];
|
|
int ksize = inpGroupCn * kernel.height * kernel.width;
|
|
return shape(out.area(), ksize);
|
|
}
|
|
|
|
bool getMemoryShapes(const std::vector<MatShape> &inputs,
|
|
const int requiredOutputs,
|
|
std::vector<MatShape> &outputs,
|
|
std::vector<MatShape> &internals) const
|
|
{
|
|
CV_Assert(blobs.size() != 0);
|
|
CV_Assert(!hasBias() || blobs[1].total() == (size_t)blobs[0].size[0]);
|
|
CV_Assert(inputs.size() == (size_t)1);
|
|
|
|
internals.clear();
|
|
|
|
int inpCn = inputs[0][1];
|
|
int inpH = inputs[0][2];
|
|
int inpW = inputs[0][3];
|
|
|
|
int outCn = blobs[0].size[0];
|
|
Size out;
|
|
|
|
if (padMode.empty())
|
|
{
|
|
out.height = (inpH + 2 * pad.height - (dilation.height * (kernel.height - 1) + 1)) / stride.height + 1;
|
|
out.width = (inpW + 2 * pad.width - (dilation.width * (kernel.width - 1) + 1)) / stride.width + 1;
|
|
}
|
|
else
|
|
{
|
|
getConvPoolOutParams(Size(inpW, inpH), kernel, stride, padMode, dilation, out);
|
|
}
|
|
|
|
int ngroups = inpCn / blobs[0].size[1];
|
|
CV_Assert(ngroups > 0 && inpCn % ngroups == 0 && outCn % ngroups == 0);
|
|
|
|
int dims[] = {inputs[0][0], outCn, out.height, out.width};
|
|
outputs.resize(inputs.size(), shape(dims));
|
|
|
|
return false;
|
|
}
|
|
|
|
bool setActivation(const Ptr<ActivationLayer>& layer)
|
|
{
|
|
activ = layer;
|
|
if (activ.empty())
|
|
reluslope.clear();
|
|
#ifdef HAVE_OPENCL
|
|
newActiv = true;
|
|
activType = OCL4DNN_CONV_FUSED_ACTIV_NONE;
|
|
|
|
if (preferableTarget == DNN_TARGET_OPENCL)
|
|
{
|
|
Ptr<PowerLayer> activ_power = activ.dynamicCast<PowerLayer>();
|
|
if (!activ_power.empty())
|
|
{
|
|
if (activ_power->scale != 1.f || activ_power->shift != 0.f)
|
|
newWeightAndBias = true;
|
|
|
|
if (activ_power->scale != 1.f)
|
|
weightsMat.release();
|
|
|
|
power = activ_power->power;
|
|
activType = OCL4DNN_CONV_FUSED_ACTIV_POWER;
|
|
}
|
|
Ptr<TanHLayer> activ_tanh = activ.dynamicCast<TanHLayer>();
|
|
if (!activ_tanh.empty())
|
|
{
|
|
activType = OCL4DNN_CONV_FUSED_ACTIV_TANH;
|
|
}
|
|
}
|
|
#endif
|
|
return !activ.empty();
|
|
}
|
|
|
|
bool setBatchNorm(const Ptr<BatchNormLayer>& layer )
|
|
{
|
|
// for now the scale layer followed by the batch norm cannot be fused, only vice versa.
|
|
if( !scaleLayer.empty() )
|
|
return false;
|
|
bnorm = layer;
|
|
// we will need to re-compute the weights with the batch
|
|
// norm coefficients taken into account
|
|
weightsMat.release();
|
|
#ifdef HAVE_OPENCL
|
|
newWeightAndBias = true;
|
|
fusedBias = false;
|
|
#endif
|
|
return !bnorm.empty();
|
|
}
|
|
|
|
bool setScale(const Ptr<ScaleLayer>& layer)
|
|
{
|
|
if (layer.empty() || layer->blobs.empty())
|
|
return false;
|
|
scaleLayer = layer;
|
|
// we will need to re-compute the weights with the scaling
|
|
// coefficients taken into account
|
|
weightsMat.release();
|
|
#ifdef HAVE_OPENCL
|
|
newWeightAndBias = true;
|
|
fusedBias = false;
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs)
|
|
{
|
|
#ifdef HAVE_HALIDE
|
|
Halide::Buffer<float> inputBuffer = halideBuffer(inputs[0]);
|
|
|
|
const int inpCn = inputBuffer.channels();
|
|
const int outCn = blobs[0].size[0];
|
|
const int inpGroupCn = blobs[0].size[1];
|
|
const int group = inpCn / inpGroupCn;
|
|
const int outGroupCn = outCn / group;
|
|
|
|
Halide::Buffer<float> weights = wrapToHalideBuffer(blobs[0]);
|
|
|
|
Halide::Var x("x"), y("y"), c("c"), n("n");
|
|
Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name));
|
|
Halide::Func padded_input(name + "_constant_exterior");
|
|
if (pad.width || pad.height)
|
|
{
|
|
Halide::Func bounded =
|
|
Halide::BoundaryConditions::constant_exterior(inputBuffer, 0);
|
|
padded_input(x, y, c, n) = bounded(x, y, c, n);
|
|
}
|
|
else
|
|
{
|
|
padded_input(x, y, c, n) = inputBuffer(x, y, c, n);
|
|
}
|
|
|
|
Halide::RDom r(0, kernel.width, 0, kernel.height, 0, inpGroupCn);
|
|
Halide::Expr kx = x * stride.width - pad.width + r.x * dilation.width;
|
|
Halide::Expr ky = y * stride.height - pad.height + r.y * dilation.height;
|
|
Halide::Expr kc = r.z;
|
|
for (int i = 1; i < group; ++i)
|
|
{
|
|
kc = select(c < outGroupCn * i, kc, inpGroupCn * i + r.z);
|
|
}
|
|
Halide::Expr topExpr = sum(padded_input(kx, ky, kc, n) *
|
|
weights(r.x, r.y, r.z, c));
|
|
if (hasBias())
|
|
{
|
|
Halide::Buffer<float> bias = wrapToHalideBuffer(blobs[1], {outCn});
|
|
topExpr += bias(c);
|
|
}
|
|
top(x, y, c, n) = topExpr;
|
|
return Ptr<BackendNode>(new HalideBackendNode({ padded_input, top }));
|
|
#endif // HAVE_HALIDE
|
|
return Ptr<BackendNode>();
|
|
}
|
|
|
|
virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> > &inputs)
|
|
{
|
|
#ifdef HAVE_INF_ENGINE
|
|
InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
|
|
CV_Assert(input->dims.size() == 4);
|
|
|
|
const int inpCn = input->dims[2]; // NOTE: input->dims are reversed (whcn)
|
|
const int outCn = blobs[0].size[0];
|
|
const int inpGroupCn = blobs[0].size[1];
|
|
const int group = inpCn / inpGroupCn;
|
|
|
|
InferenceEngine::LayerParams lp;
|
|
lp.name = name;
|
|
lp.type = "Convolution";
|
|
lp.precision = InferenceEngine::Precision::FP32;
|
|
std::shared_ptr<InferenceEngine::ConvolutionLayer> ieLayer(new InferenceEngine::ConvolutionLayer(lp));
|
|
|
|
ieLayer->_kernel_x = kernel.width;
|
|
ieLayer->_kernel_y = kernel.height;
|
|
ieLayer->_stride_x = stride.width;
|
|
ieLayer->_stride_y = stride.height;
|
|
ieLayer->_out_depth = outCn;
|
|
ieLayer->_padding_x = pad.width;
|
|
ieLayer->_padding_y = pad.height;
|
|
ieLayer->_dilation_x = dilation.width;
|
|
ieLayer->_dilation_y = dilation.height;
|
|
ieLayer->_group = group;
|
|
|
|
ieLayer->_weights = wrapToInfEngineBlob(blobs[0]);
|
|
if (hasBias())
|
|
ieLayer->_biases = wrapToInfEngineBlob(blobs[1]);
|
|
return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
|
|
#endif // HAVE_INF_ENGINE
|
|
return Ptr<BackendNode>();
|
|
}
|
|
|
|
class ParallelConv : public cv::ParallelLoopBody
|
|
{
|
|
public:
|
|
enum { BLK_SIZE = 32, BLK_SIZE_CN = 64 };
|
|
|
|
const Mat* input_;
|
|
const Mat* weights_;
|
|
Mat* output_;
|
|
int outShape[4];
|
|
Size kernel_, pad_, stride_, dilation_;
|
|
int ngroups_, nstripes_;
|
|
std::vector<int> ofstab_;
|
|
const std::vector<float>* biasvec_;
|
|
const std::vector<float>* reluslope_;
|
|
const ActivationLayer* activ_;
|
|
bool is1x1_;
|
|
bool useAVX;
|
|
bool useAVX2;
|
|
bool useAVX512;
|
|
|
|
ParallelConv()
|
|
: input_(0), weights_(0), output_(0), ngroups_(0), nstripes_(0),
|
|
biasvec_(0), reluslope_(0), activ_(0), is1x1_(false), useAVX(false), useAVX2(false), useAVX512(false)
|
|
{}
|
|
|
|
static void run( const Mat& input, Mat& output, const Mat& weights,
|
|
const std::vector<float>& biasvec,
|
|
const std::vector<float>& reluslope,
|
|
Size kernel, Size pad, Size stride, Size dilation,
|
|
const ActivationLayer* activ, int ngroups, int nstripes )
|
|
{
|
|
CV_Assert( input.dims == 4 && output.dims == 4,
|
|
input.size[0] == output.size[0],
|
|
weights.rows == output.size[1],
|
|
weights.cols == (input.size[1]/ngroups)*kernel.width*kernel.height,
|
|
input.type() == output.type(),
|
|
input.type() == weights.type(),
|
|
input.type() == CV_32F,
|
|
input.isContinuous(),
|
|
output.isContinuous(),
|
|
biasvec.size() == (size_t)output.size[1]+2);
|
|
ParallelConv p;
|
|
|
|
p.input_ = &input;
|
|
p.weights_ = &weights;
|
|
p.output_ = &output;
|
|
for( int i = 0; i < 4; i++ ) p.outShape[i] = output.size[i];
|
|
p.outShape[1] /= ngroups;
|
|
p.kernel_ = kernel; p.pad_ = pad; p.stride_ = stride; p.dilation_ = dilation;
|
|
p.ngroups_ = ngroups;
|
|
p.nstripes_ = nstripes;
|
|
|
|
int inpCnAll = input.size[1], width = input.size[3], height = input.size[2];
|
|
int inpCn = inpCnAll / ngroups;
|
|
p.is1x1_ = kernel == Size(0,0) && pad == Size(0, 0);
|
|
p.useAVX = checkHardwareSupport(CPU_AVX);
|
|
p.useAVX2 = checkHardwareSupport(CPU_AVX2);
|
|
p.useAVX512 = CV_CPU_HAS_SUPPORT_AVX512_SKX;
|
|
|
|
int ncn = std::min(inpCn, (int)BLK_SIZE_CN);
|
|
p.ofstab_.resize(kernel.width*kernel.height*ncn);
|
|
int* ofstab = &p.ofstab_[0];
|
|
|
|
for( int k = 0; k < ncn; k++ )
|
|
for( int k_r = 0; k_r < kernel.height; k_r++ )
|
|
for( int k_c = 0; k_c < kernel.width; k_c++ )
|
|
ofstab[(k*kernel.height + k_r)*kernel.width + k_c] =
|
|
(k*height + k_r*dilation.height)*width + k_c*dilation.width;
|
|
|
|
p.biasvec_ = &biasvec;
|
|
p.reluslope_ = &reluslope;
|
|
p.activ_ = p.reluslope_->empty() ? activ : 0;
|
|
|
|
parallel_for_(Range(0, nstripes), p, nstripes);
|
|
}
|
|
|
|
virtual void operator ()(const Range &r0) const
|
|
{
|
|
const int valign = ConvolutionLayerImpl::VEC_ALIGN;
|
|
int ngroups = ngroups_, batchSize = input_->size[0]*ngroups;
|
|
int outW = output_->size[3], outH = output_->size[2], outCn = output_->size[1]/ngroups;
|
|
int width = input_->size[3], height = input_->size[2], inpCn = input_->size[1]/ngroups;
|
|
int nstripes = nstripes_;
|
|
int kernel_w = kernel_.width, kernel_h = kernel_.height;
|
|
int pad_w = pad_.width, pad_h = pad_.height;
|
|
int stride_w = stride_.width, stride_h = stride_.height;
|
|
int dilation_w = dilation_.width, dilation_h = dilation_.height;
|
|
int karea = kernel_w*kernel_h;
|
|
int i, j, k;
|
|
size_t inpPlaneSize = width*height;
|
|
size_t outPlaneSize = outW*outH;
|
|
bool is1x1 = is1x1_;
|
|
|
|
int stripesPerSample;
|
|
size_t stripeSize;
|
|
Range r = r0;
|
|
|
|
if( nstripes >= batchSize*2 )
|
|
{
|
|
stripesPerSample = nstripes/batchSize;
|
|
stripeSize = alignSize((outPlaneSize + stripesPerSample - 1)/stripesPerSample, valign);
|
|
stripeSize = std::min(stripeSize, outPlaneSize);
|
|
}
|
|
else
|
|
{
|
|
stripesPerSample = 1;
|
|
int samplesPerStripe = std::max((batchSize + nstripes - 1)/nstripes, 1);
|
|
r.start *= samplesPerStripe;
|
|
r.end *= samplesPerStripe;
|
|
nstripes *= samplesPerStripe;
|
|
stripeSize = outPlaneSize;
|
|
}
|
|
|
|
const float* data_inp0_ = input_->ptr<float>();
|
|
const int* ofstab = &ofstab_[0];
|
|
const float* wptr_orig_ = weights_->ptr<float>();
|
|
size_t wstep = weights_->step1();
|
|
const float* biasptr_ = &biasvec_->at(0);
|
|
const float* reluptr_ = reluslope_->empty() ? 0 : &reluslope_->at(0);
|
|
float* data_out0_ = output_->ptr<float>();
|
|
size_t rowbufsz = (size_t)karea*BLK_SIZE_CN*BLK_SIZE;
|
|
AutoBuffer<float> rowbuf0_(rowbufsz + valign);
|
|
float* rowbuf0 = alignPtr((float*)rowbuf0_, (int)(valign*sizeof(float)));
|
|
|
|
// we clear the buffer once; ultimately, it lets us to avoid
|
|
// tail processing after running the unrolled/vectorized loop.
|
|
// the main idea is to make sure that the tail (a.k.a. padding) of each row
|
|
// (i.e. the elements with indices between vsz=karea*ncn and vsz_a)
|
|
// does not contain NaNs or Infs. Because the padding in the weights
|
|
// matrix is explicitly initialized with 0's, we handle all other
|
|
// cases nicely, i.e. we can skip expliciting re-initialization
|
|
// of the padding - we just retain elements from the previous iteration
|
|
// of the loop over channels (cn0).
|
|
memset(rowbuf0, 0, rowbufsz*sizeof(rowbuf0[0]) );
|
|
|
|
for( int stripe = r.start; stripe < r.end; stripe++ )
|
|
{
|
|
int subsampleIdx = stripe/stripesPerSample;
|
|
if( subsampleIdx >= batchSize )
|
|
break;
|
|
int stripeStart = (int)((stripe - subsampleIdx*stripesPerSample)*stripeSize);
|
|
int stripeEnd = (int)std::min(stripeStart + stripeSize, outPlaneSize);
|
|
const float* data_inp0 = data_inp0_ + subsampleIdx*inpPlaneSize*inpCn;
|
|
float* data_out0 = data_out0_ + subsampleIdx*outPlaneSize*outCn;
|
|
int startOutCn = (subsampleIdx % ngroups)*outCn;
|
|
const float* wptr_orig = wptr_orig_ + wstep*startOutCn;
|
|
const float* biasptr = biasptr_ + startOutCn;
|
|
|
|
for( int cn0 = 0; cn0 < inpCn; cn0 += BLK_SIZE_CN )
|
|
{
|
|
int cn1 = std::min(cn0 + BLK_SIZE_CN, inpCn);
|
|
int ncn = cn1 - cn0, vsz = karea*ncn;
|
|
int vsz_a = (int)alignSize(vsz, valign);
|
|
const float* wptr = wptr_orig + cn0*karea;
|
|
// we apply [Channels][P]ReLU (if any) during the final pass only.
|
|
const float* relu = cn1 == inpCn && reluptr_ ? reluptr_ + startOutCn : 0;
|
|
|
|
for( int ofs0 = stripeStart; ofs0 < stripeEnd; ofs0 += BLK_SIZE )
|
|
{
|
|
int ofs, ofs1 = std::min(ofs0 + BLK_SIZE, stripeEnd);
|
|
int out_i = ofs0 / outW;
|
|
int out_j = ofs0 - out_i * outW;
|
|
|
|
// do im2row for a part of input tensor
|
|
float* rowbuf = rowbuf0;
|
|
for( ofs = ofs0; ofs < ofs1; out_j = 0, ++out_i )
|
|
{
|
|
int delta = std::min(ofs1 - ofs, outW - out_j);
|
|
int out_j1 = out_j + delta;
|
|
int in_i = out_i * stride_h - pad_h;
|
|
int in_j = out_j * stride_w - pad_w;
|
|
const float* imgptr = data_inp0 + (cn0*height + in_i)*width + in_j;
|
|
ofs += delta;
|
|
|
|
// do im2row for a part of input tensor
|
|
if( is1x1 )
|
|
{
|
|
for( ; out_j < out_j1; out_j++, rowbuf += vsz_a, imgptr += stride_w )
|
|
{
|
|
for( k = 0; k < vsz; k++ )
|
|
rowbuf[k] = imgptr[k*inpPlaneSize];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool ok_i = 0 <= in_i && in_i < height - (kernel_h-1)*dilation_h;
|
|
int i0 = std::max(0, (-in_i + dilation_h-1)/dilation_h);
|
|
int i1 = std::min(kernel_h, (height - in_i + dilation_h-1)/dilation_h);
|
|
|
|
for( ; out_j < out_j1; out_j++, rowbuf += vsz_a, imgptr += stride_w, in_j += stride_w )
|
|
{
|
|
// this condition should be true for most of the tensor elements, i.e.
|
|
// most of the time the kernel aperture is inside the tensor X-Y plane.
|
|
if( ok_i && out_j + 2 <= out_j1 && 0 <= in_j && in_j + stride_w*2 <= width - (kernel_w-1)*dilation_w )
|
|
{
|
|
for( k = 0; k < vsz; k++ )
|
|
{
|
|
int k1 = ofstab[k];
|
|
float v0 = imgptr[k1];
|
|
float v1 = imgptr[k1 + stride_w];
|
|
rowbuf[k] = v0;
|
|
rowbuf[k+vsz_a] = v1;
|
|
}
|
|
out_j++;
|
|
rowbuf += vsz_a;
|
|
imgptr += stride_w;
|
|
in_j += stride_w;
|
|
}
|
|
else
|
|
{
|
|
int j0 = std::max(0, (-in_j + dilation_w-1)/dilation_w);
|
|
int j1 = std::min(kernel_w, (width - in_j + dilation_w-1)/dilation_w);
|
|
|
|
// here some non-continous sub-row of the row will not be
|
|
// filled from the tensor; we need to make sure that the uncovered
|
|
// elements are explicitly set to 0's. the easiest way is to
|
|
// set all the elements to 0's before the loop.
|
|
memset(rowbuf, 0, vsz*sizeof(rowbuf[0]));
|
|
for( k = 0; k < ncn; k++ )
|
|
{
|
|
for( i = i0; i < i1; i++ )
|
|
{
|
|
for( j = j0; j < j1; j++ )
|
|
{
|
|
int imgofs = k*(width*height) + i*(dilation_h*width) + j*dilation_w;
|
|
rowbuf[(k*kernel_h + i)*kernel_w + j] = imgptr[imgofs];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// now compute dot product of the weights
|
|
// and im2row-transformed part of the tensor
|
|
int bsz = ofs1 - ofs0;
|
|
#if CV_TRY_AVX512_SKX
|
|
/* AVX512 convolution requires an alignment of 16, and ROI is only there for larger vector sizes */
|
|
if(useAVX512)
|
|
opt_AVX512_SKX::fastConv(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0,
|
|
outShape, bsz, vsz, vsz_a, relu, cn0 == 0);
|
|
else
|
|
#endif
|
|
#if CV_TRY_AVX2
|
|
if(useAVX2)
|
|
opt_AVX2::fastConv(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0,
|
|
outShape, bsz, vsz, vsz_a, relu, cn0 == 0);
|
|
else
|
|
#endif
|
|
#if CV_TRY_AVX
|
|
if(useAVX)
|
|
opt_AVX::fastConv(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0,
|
|
outShape, bsz, vsz, vsz_a, relu, cn0 == 0);
|
|
else
|
|
#endif
|
|
for( int i = 0; i < outCn; i += 2 )
|
|
{
|
|
const float* wptr0 = wptr + i*wstep;
|
|
const float* wptr1 = wptr0 + wstep;
|
|
float* outptr0 = data_out0 + ofs0 + i*outPlaneSize;
|
|
float* outptr1 = outptr0 + outPlaneSize;
|
|
float bias0 = biasptr[i], bias1 = biasptr[i+1];
|
|
float r0 = 1.f, r1 = 1.f;
|
|
|
|
if( i+1 >= outCn )
|
|
{
|
|
wptr1 = wptr0;
|
|
outptr1 = outptr0;
|
|
bias1 = bias0;
|
|
}
|
|
|
|
if( relu )
|
|
{
|
|
r0 = relu[i];
|
|
r1 = relu[i+1];
|
|
}
|
|
|
|
int j = 0;
|
|
#if CV_SIMD128
|
|
v_float32x4 vr0 = v_setall_f32(r0), vr1 = v_setall_f32(r1), z = v_setzero_f32();
|
|
|
|
for( ; j <= bsz - 4; j += 4 )
|
|
{
|
|
const float* rptr = rowbuf0 + j*vsz_a;
|
|
v_float32x4 s0, s1;
|
|
|
|
if( cn0 == 0 )
|
|
{
|
|
s0 = v_setall_f32(bias0);
|
|
s1 = v_setall_f32(bias1);
|
|
}
|
|
else
|
|
{
|
|
s0 = v_load(outptr0 + j);
|
|
s1 = v_load(outptr1 + j);
|
|
}
|
|
|
|
v_float32x4 vs00 = v_setzero_f32(), vs01 = v_setzero_f32(),
|
|
vs02 = v_setzero_f32(), vs03 = v_setzero_f32(),
|
|
vs10 = v_setzero_f32(), vs11 = v_setzero_f32(),
|
|
vs12 = v_setzero_f32(), vs13 = v_setzero_f32();
|
|
for( k = 0; k < vsz; k += 4, rptr += 4 )
|
|
{
|
|
v_float32x4 w0 = v_load_aligned(wptr0 + k), w1 = v_load_aligned(wptr1 + k);
|
|
v_float32x4 r0 = v_load_aligned(rptr), r1 = v_load_aligned(rptr + vsz_a),
|
|
r2 = v_load_aligned(rptr + vsz_a*2), r3 = v_load_aligned(rptr + vsz_a*3);
|
|
|
|
vs00 += w0*r0;
|
|
vs01 += w0*r1;
|
|
vs02 += w0*r2;
|
|
vs03 += w0*r3;
|
|
|
|
vs10 += w1*r0;
|
|
vs11 += w1*r1;
|
|
vs12 += w1*r2;
|
|
vs13 += w1*r3;
|
|
}
|
|
s0 += v_reduce_sum4(vs00, vs01, vs02, vs03);
|
|
s1 += v_reduce_sum4(vs10, vs11, vs12, vs13);
|
|
if( relu )
|
|
{
|
|
s0 = v_select(s0 > z, s0, s0*vr0);
|
|
s1 = v_select(s1 > z, s1, s1*vr1);
|
|
}
|
|
|
|
v_store(outptr0 + j, s0);
|
|
v_store(outptr1 + j, s1);
|
|
}
|
|
#endif
|
|
for( ; j < bsz; j++ )
|
|
{
|
|
const float* rptr = rowbuf0 + j*vsz_a;
|
|
float s00, s10;
|
|
|
|
if( cn0 == 0 )
|
|
{
|
|
s00 = bias0;
|
|
s10 = bias1;
|
|
}
|
|
else
|
|
{
|
|
s00 = outptr0[j];
|
|
s10 = outptr1[j];
|
|
}
|
|
|
|
for( k = 0; k < vsz; k++ )
|
|
{
|
|
float r0 = rptr[k];
|
|
s00 += wptr0[k]*r0;
|
|
s10 += wptr1[k]*r0;
|
|
}
|
|
if( relu )
|
|
{
|
|
s00 = s00 > 0.f ? s00 : s00*r0;
|
|
s10 = s10 > 0.f ? s10 : s10*r1;
|
|
}
|
|
|
|
outptr0[j] = s00;
|
|
outptr1[j] = s10;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( activ_ )
|
|
activ_->forwardSlice(data_out0 + stripeStart, data_out0 + stripeStart,
|
|
(int)(stripeEnd - stripeStart),
|
|
outPlaneSize, startOutCn, startOutCn + outCn);
|
|
}
|
|
}
|
|
};
|
|
|
|
#ifdef HAVE_OPENCL
|
|
bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals)
|
|
{
|
|
std::vector<UMat> inputs;
|
|
std::vector<UMat> outputs;
|
|
|
|
inps.getUMatVector(inputs);
|
|
outs.getUMatVector(outputs);
|
|
|
|
CV_Assert(outputs.size() == 1);
|
|
for (int i = 0; i < inputs.size(); ++i)
|
|
CV_Assert(inputs[i].u != outputs[0].u);
|
|
|
|
int inpH = inputs[0].size[2];
|
|
int inpW = inputs[0].size[3];
|
|
int out_h = (inpH + 2 * pad.height - (dilation.height * (kernel.height - 1) + 1)) / stride.height + 1;
|
|
int out_w = (inpW + 2 * pad.width - (dilation.width * (kernel.width - 1) + 1)) / stride.width + 1;
|
|
if (out_h != outputs[0].size[2] || out_w != outputs[0].size[3])
|
|
return false;
|
|
|
|
int group = inputs[0].size[1] / umat_blobs[0].size[1];
|
|
|
|
if (convolutionOp.empty())
|
|
{
|
|
OCL4DNNConvConfig config;
|
|
config.in_shape = shape(inputs[0]);
|
|
config.out_shape = shape(outputs[0]);
|
|
config.kernel = kernel;
|
|
config.pad = pad;
|
|
config.stride = stride;
|
|
config.dilation = dilation;
|
|
config.group = group;
|
|
config.bias_term = (hasBias()) ? true : false;
|
|
|
|
convolutionOp = Ptr<OCL4DNNConvSpatial<float> >(new OCL4DNNConvSpatial<float>(config));
|
|
}
|
|
|
|
int k, outCn = umat_blobs[0].size[0];
|
|
if( weightsMat.empty() )
|
|
{
|
|
// prepare weightsMat where each row is aligned and has enough zero padding on the right to
|
|
// use vectorized (i.e. with intrinsics) loops without tail processing
|
|
Mat wm = blobs[0].reshape(1, outCn).clone();
|
|
if( wm.step1() % VEC_ALIGN != 0 )
|
|
{
|
|
int newcols = (int)alignSize(wm.step1(), VEC_ALIGN);
|
|
Mat wm_buffer = Mat(outCn, newcols, wm.type());
|
|
Mat wm_padding = wm_buffer.colRange(wm.cols, newcols);
|
|
wm_padding.setTo(Scalar::all(0.));
|
|
Mat wm_aligned = wm_buffer.colRange(0, wm.cols);
|
|
wm.copyTo(wm_aligned);
|
|
wm = wm_aligned;
|
|
}
|
|
weightsMat = wm;
|
|
|
|
Mat biasMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat();
|
|
biasvec.resize(outCn+2);
|
|
if( biasMat.empty() )
|
|
{
|
|
for( k = 0; k < outCn; k++ )
|
|
biasvec[k] = 0.f;
|
|
}
|
|
else
|
|
{
|
|
for( k = 0; k < outCn; k++ )
|
|
biasvec[k] = biasMat.at<float>(k);
|
|
}
|
|
|
|
if( !bnorm.empty() || !scaleLayer.empty() || IS_POWER_LAYER(activ))
|
|
{
|
|
Mat scale, shift, scale2, shift2;
|
|
const float *scaleptr = 0, *shiftptr = 0;
|
|
const float *scaleptr2 = 0, *shiftptr2 = 0;
|
|
float a = 1.f, b = 0.f;
|
|
|
|
if( !bnorm.empty() )
|
|
{
|
|
bnorm->getScaleShift(scale, shift);
|
|
CV_Assert( scale.isContinuous() && shift.isContinuous() &&
|
|
scale.type() == CV_32F && shift.type() == CV_32F &&
|
|
scale.total() == (size_t)outCn &&
|
|
shift.total() == (size_t)outCn );
|
|
scaleptr = scale.ptr<float>();
|
|
shiftptr = shift.ptr<float>();
|
|
}
|
|
if( !scaleLayer.empty() )
|
|
{
|
|
scale2 = scaleLayer->blobs[0];
|
|
CV_Assert( scale2.isContinuous() && scale2.type() == CV_32F &&
|
|
scale2.total() == (size_t)outCn );
|
|
scaleptr2 = scale2.ptr<float>();
|
|
if( scaleLayer->hasBias )
|
|
{
|
|
shift2 = scaleLayer->blobs[1];
|
|
CV_Assert( shift2.isContinuous() && shift2.type() == CV_32F &&
|
|
shift2.total() == (size_t)outCn );
|
|
shiftptr2 = shift2.ptr<float>();
|
|
}
|
|
}
|
|
|
|
if( IS_POWER_LAYER(activ) )
|
|
{
|
|
Ptr<PowerLayer> activ_power = activ.dynamicCast<PowerLayer>();
|
|
CV_Assert(activ_power);
|
|
a = activ_power->scale;
|
|
b = activ_power->shift;
|
|
}
|
|
|
|
if (shiftptr || shiftptr2 || b != 0.f)
|
|
fusedBias = true;
|
|
|
|
for( int i = 0; i < outCn; i++ )
|
|
{
|
|
float s1 = scaleptr ? scaleptr[i] : 1.f;
|
|
float delta1 = shiftptr ? shiftptr[i] : 0.f;
|
|
float s2 = scaleptr2 ? scaleptr2[i] : 1.f;
|
|
float delta2 = shiftptr2 ? shiftptr2[i] : 0.f;
|
|
float* w_i = weightsMat.ptr<float>(i);
|
|
int j, wcols = weightsMat.cols;
|
|
|
|
for( j = 0; j < wcols; j++ )
|
|
w_i[j] *= (s1*s2*a);
|
|
|
|
biasvec[i] = biasvec[i]*(s1*s2*a) + (delta1*s2*a + delta2*a + b);
|
|
}
|
|
}
|
|
biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1];
|
|
}
|
|
|
|
reluslope.clear();
|
|
if( activ )
|
|
{
|
|
Ptr<ReLULayer> activ_relu = activ.dynamicCast<ReLULayer>();
|
|
if( !activ_relu.empty() )
|
|
{
|
|
reluslope.assign(outCn+2, activ_relu->negativeSlope);
|
|
activType = OCL4DNN_CONV_FUSED_ACTIV_RELU;
|
|
}
|
|
|
|
Ptr<ChannelsPReLULayer> activ_chprelu = activ.dynamicCast<ChannelsPReLULayer>();
|
|
if( !activ_chprelu.empty() )
|
|
{
|
|
const Mat& m = activ_chprelu->blobs[0];
|
|
CV_Assert(m.isContinuous() && m.type() == CV_32F && (int)m.total() == outCn);
|
|
const float* mdata = m.ptr<float>();
|
|
reluslope.resize(outCn+2);
|
|
std::copy(mdata, mdata + outCn, reluslope.begin());
|
|
reluslope[outCn] = reluslope[outCn+1] = reluslope[outCn-1];
|
|
activType = OCL4DNN_CONV_FUSED_ACTIV_PRELU;
|
|
}
|
|
}
|
|
|
|
if ( newWeightAndBias )
|
|
{
|
|
weightsMat.copyTo(umat_blobs[0]);
|
|
if ( fusedBias )
|
|
{
|
|
if ( umat_blobs.size() < 2 )
|
|
umat_blobs.resize(2);
|
|
umat_blobs[1] = UMat(biasvec, true);
|
|
}
|
|
convolutionOp->setBias(fusedBias || hasBias());
|
|
newWeightAndBias = false;
|
|
}
|
|
|
|
if ( newActiv )
|
|
{
|
|
if ( activType == OCL4DNN_CONV_FUSED_ACTIV_RELU )
|
|
{
|
|
CV_Assert(!reluslope.empty());
|
|
convolutionOp->setActivReLU(true, reluslope[0]);
|
|
}
|
|
else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_PRELU)
|
|
{
|
|
CV_Assert(!reluslope.empty());
|
|
convolutionOp->setActivPReLU(true, reluslope);
|
|
}
|
|
else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_POWER)
|
|
{
|
|
convolutionOp->setActivPower(true, power);
|
|
}
|
|
else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_TANH)
|
|
{
|
|
convolutionOp->setActivTanh(true);
|
|
}
|
|
else
|
|
{
|
|
convolutionOp->setActivReLU(false, 0);
|
|
convolutionOp->setActivPReLU(false, reluslope);
|
|
convolutionOp->setActivPower(false, 1.f);
|
|
convolutionOp->setActivTanh(false);
|
|
}
|
|
newActiv = false;
|
|
}
|
|
|
|
UMat& inpMat = inputs[0];
|
|
UMat& outMat = outputs[0];
|
|
int batch_size = inpMat.size[0];
|
|
|
|
return convolutionOp->Forward(inpMat,
|
|
inputs.size() == 2 ? inputs[1] : UMat(),
|
|
umat_blobs[0],
|
|
(hasBias() || fusedBias) ? umat_blobs[1] : UMat(),
|
|
outMat,
|
|
batch_size);
|
|
}
|
|
#endif
|
|
|
|
void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr)
|
|
{
|
|
CV_TRACE_FUNCTION();
|
|
CV_TRACE_ARG_VALUE(name, "name", name.c_str());
|
|
|
|
CV_OCL_RUN((preferableTarget == DNN_TARGET_OPENCL) &&
|
|
OCL_PERFORMANCE_CHECK(ocl::Device::getDefault().isIntel()),
|
|
forward_ocl(inputs_arr, outputs_arr, internals_arr))
|
|
|
|
Layer::forward_fallback(inputs_arr, outputs_arr, internals_arr);
|
|
}
|
|
|
|
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals)
|
|
{
|
|
CV_TRACE_FUNCTION();
|
|
CV_TRACE_ARG_VALUE(name, "name", name.c_str());
|
|
|
|
/*printf("conv %s: input (%d x %d x %d x %d), kernel (%d x %d), pad (%d x %d), stride (%d x %d), dilation (%d x %d)\n",
|
|
name.c_str(), inputs[0]->size[0], inputs[0]->size[1], inputs[0]->size[2], inputs[0]->size[3],
|
|
kernel.width, kernel.height, pad.width, pad.height,
|
|
stride.width, stride.height, dilation.width, dilation.height);*/
|
|
CV_Assert(inputs.size() == (size_t)1, inputs[0]->size[1] % blobs[0].size[1] == 0,
|
|
outputs.size() == 1, inputs[0]->data != outputs[0].data);
|
|
|
|
int ngroups = inputs[0]->size[1]/blobs[0].size[1];
|
|
CV_Assert(outputs[0].size[1] % ngroups == 0);
|
|
int k, outCn = blobs[0].size[0];
|
|
|
|
if( weightsMat.empty() )
|
|
{
|
|
// prepare weightsMat where each row is aligned and has enough zero padding on the right to
|
|
// use vectorized (i.e. with intrinsics) loops without tail processing
|
|
Mat wm = blobs[0].reshape(1, outCn).clone();
|
|
if( wm.step1() % VEC_ALIGN != 0 )
|
|
{
|
|
int newcols = (int)alignSize(wm.step1(), VEC_ALIGN);
|
|
Mat wm_buffer = Mat(outCn, newcols, wm.type());
|
|
Mat wm_padding = wm_buffer.colRange(wm.cols, newcols);
|
|
wm_padding.setTo(Scalar::all(0.));
|
|
Mat wm_aligned = wm_buffer.colRange(0, wm.cols);
|
|
wm.copyTo(wm_aligned);
|
|
wm = wm_aligned;
|
|
}
|
|
weightsMat = wm;
|
|
|
|
Mat biasMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat();
|
|
biasvec.resize(outCn+2);
|
|
if( biasMat.empty() )
|
|
{
|
|
for( k = 0; k < outCn; k++ )
|
|
biasvec[k] = 0.f;
|
|
}
|
|
else
|
|
{
|
|
for( k = 0; k < outCn; k++ )
|
|
biasvec[k] = biasMat.at<float>(k);
|
|
}
|
|
|
|
if( !bnorm.empty() || !scaleLayer.empty() )
|
|
{
|
|
Mat scale, shift, scale2, shift2;
|
|
const float *scaleptr = 0, *shiftptr = 0;
|
|
const float *scaleptr2 = 0, *shiftptr2 = 0;
|
|
|
|
if( !bnorm.empty() )
|
|
{
|
|
bnorm->getScaleShift(scale, shift);
|
|
CV_Assert( scale.isContinuous() && shift.isContinuous() &&
|
|
scale.type() == CV_32F && shift.type() == CV_32F &&
|
|
scale.total() == (size_t)outCn &&
|
|
shift.total() == (size_t)outCn );
|
|
scaleptr = scale.ptr<float>();
|
|
shiftptr = shift.ptr<float>();
|
|
}
|
|
if( !scaleLayer.empty() )
|
|
{
|
|
scale2 = scaleLayer->blobs[0];
|
|
CV_Assert( scale2.isContinuous() && scale2.type() == CV_32F &&
|
|
scale2.total() == (size_t)outCn );
|
|
scaleptr2 = scale2.ptr<float>();
|
|
if( scaleLayer->hasBias )
|
|
{
|
|
shift2 = scaleLayer->blobs[1];
|
|
CV_Assert( shift2.isContinuous() && shift2.type() == CV_32F &&
|
|
shift2.total() == (size_t)outCn );
|
|
shiftptr2 = shift2.ptr<float>();
|
|
}
|
|
}
|
|
|
|
for( int i = 0; i < outCn; i++ )
|
|
{
|
|
float s1 = scaleptr ? scaleptr[i] : 1.f;
|
|
float delta1 = shiftptr ? shiftptr[i] : 0.f;
|
|
float s2 = scaleptr2 ? scaleptr2[i] : 1.f;
|
|
float delta2 = shiftptr2 ? shiftptr2[i] : 0.f;
|
|
float* w_i = weightsMat.ptr<float>(i);
|
|
int j, wcols = weightsMat.cols;
|
|
|
|
for( j = 0; j < wcols; j++ )
|
|
w_i[j] *= (s1*s2);
|
|
|
|
biasvec[i] = biasvec[i]*(s1*s2) + (delta1*s2 + delta2);
|
|
}
|
|
}
|
|
biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1];
|
|
}
|
|
|
|
reluslope.clear();
|
|
if( activ )
|
|
{
|
|
Ptr<ReLULayer> activ_relu = activ.dynamicCast<ReLULayer>();
|
|
if( !activ_relu.empty() )
|
|
{
|
|
reluslope.assign(outCn+2, activ_relu->negativeSlope);
|
|
}
|
|
|
|
Ptr<ChannelsPReLULayer> activ_chprelu = activ.dynamicCast<ChannelsPReLULayer>();
|
|
if( !activ_chprelu.empty() )
|
|
{
|
|
const Mat& m = activ_chprelu->blobs[0];
|
|
CV_Assert(m.isContinuous() && m.type() == CV_32F && (int)m.total() == outCn);
|
|
const float* mdata = m.ptr<float>();
|
|
reluslope.resize(outCn+2);
|
|
std::copy(mdata, mdata + outCn, reluslope.begin());
|
|
reluslope[outCn] = reluslope[outCn+1] = reluslope[outCn-1];
|
|
}
|
|
}
|
|
|
|
int nstripes = std::max(getNumThreads(), 1);
|
|
|
|
ParallelConv::run(*inputs[0], outputs[0], weightsMat, biasvec, reluslope,
|
|
kernel, pad, stride, dilation, activ.get(), ngroups, nstripes);
|
|
}
|
|
|
|
virtual int64 getFLOPS(const std::vector<MatShape> &inputs,
|
|
const std::vector<MatShape> &outputs) const
|
|
{
|
|
CV_Assert(inputs.size() == outputs.size());
|
|
|
|
int64 flops = 0;
|
|
for (int i = 0; i < inputs.size(); i++)
|
|
{
|
|
flops += total(outputs[i])*(CV_BIG_INT(2)*kernel.area()*inputs[i][1] + 1);
|
|
}
|
|
|
|
return flops;
|
|
}
|
|
};
|
|
|
|
class DeConvolutionLayerImpl : public BaseConvolutionLayerImpl
|
|
{
|
|
public:
|
|
Mat weightsMat, biasesMat;
|
|
UMat umat_weights;
|
|
UMat umat_biases;
|
|
|
|
MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const
|
|
{
|
|
int inpCn = inpShape[1];
|
|
int inpH = inpShape[2];
|
|
int inpW = inpShape[3];
|
|
int outCn = outShape[1];
|
|
int ngroups = inpCn / blobs[0].size[0];
|
|
int outGroupCn = outCn / ngroups;
|
|
int ksize = outGroupCn * kernel.height * kernel.width;
|
|
return shape(ksize, inpH * inpW);
|
|
}
|
|
|
|
bool getMemoryShapes(const std::vector<MatShape> &inputs,
|
|
const int requiredOutputs,
|
|
std::vector<MatShape> &outputs,
|
|
std::vector<MatShape> &internals) const
|
|
{
|
|
CV_Assert(!hasBias() || blobs[1].total() == (size_t)numOutput);
|
|
CV_Assert(inputs.size() != 0);
|
|
|
|
int inpCn = inputs[0][1];
|
|
int inpH = inputs[0][2];
|
|
int inpW = inputs[0][3];
|
|
|
|
int outH = stride.height * (inpH - 1) + kernel.height - 2 * pad.height + adjustPad.height;
|
|
int outW = stride.width * (inpW - 1) + kernel.width - 2 * pad.width + adjustPad.width;
|
|
int outCn = numOutput;
|
|
|
|
CV_Assert(outCn % blobs[0].size[1] == 0);
|
|
int ngroups = outCn / blobs[0].size[1];
|
|
|
|
CV_Assert(inpCn % ngroups == 0 && outCn % ngroups == 0);
|
|
CV_Assert(blobs[0].size[0] == inpCn);
|
|
|
|
int dims[] = {inputs[0][0], outCn, outH, outW};
|
|
outputs.resize(inputs.size(), shape(dims));
|
|
|
|
internals.push_back(MatShape());
|
|
if (!is1x1())
|
|
internals[0] = computeColRowShape(inputs[0], outputs[0]);
|
|
|
|
if (hasBias())
|
|
internals.push_back(shape(1, outH*outW));
|
|
|
|
return false;
|
|
}
|
|
|
|
class MatMulInvoker : public ParallelLoopBody
|
|
{
|
|
public:
|
|
MatMulInvoker(const Mat& a, const Mat& b, Mat& c, int nstripes)
|
|
{
|
|
a_ = &a;
|
|
b_ = &b;
|
|
c_ = &c;
|
|
nstripes_ = nstripes;
|
|
useAVX = checkHardwareSupport(CPU_AVX);
|
|
useAVX2 = checkHardwareSupport(CPU_AVX2);
|
|
useAVX512 = CV_CPU_HAS_SUPPORT_AVX512_SKX;
|
|
}
|
|
|
|
void operator()(const Range& range_) const
|
|
{
|
|
int stripeSize = (int)alignSize((b_->cols + nstripes_ - 1)/nstripes_, 16);
|
|
Range range(range_.start*stripeSize, std::min(range_.end*stripeSize, b_->cols));
|
|
int mmax = a_->rows;
|
|
int nmax = range.end - range.start;
|
|
int kmax = a_->cols;
|
|
int m, n, k;
|
|
const float* aptr = a_->ptr<float>();
|
|
const float* bptr = b_->ptr<float>() + range.start;
|
|
float* cptr = c_->ptr<float>() + range.start;
|
|
size_t astep = a_->step1();
|
|
size_t bstep = b_->step1();
|
|
size_t cstep = c_->step1();
|
|
|
|
#if CV_TRY_AVX512_SKX
|
|
if( useAVX512 )
|
|
opt_AVX512_SKX::fastGEMM( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax );
|
|
else
|
|
#endif
|
|
#if CV_TRY_AVX2
|
|
if( useAVX2 )
|
|
opt_AVX2::fastGEMM( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax );
|
|
else
|
|
#endif
|
|
#if CV_TRY_AVX
|
|
if( useAVX )
|
|
opt_AVX::fastGEMM( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax );
|
|
else
|
|
#endif
|
|
for( m = 0; m < mmax; m += 2 )
|
|
{
|
|
float* dst0 = cptr + cstep*m;
|
|
float* dst1 = cptr + cstep*std::min(m+1, mmax-1);
|
|
const float* aptr0 = aptr + astep*m;
|
|
const float* aptr1 = aptr + astep*std::min(m+1, mmax-1);
|
|
|
|
for( n = 0; n < nmax; n++ )
|
|
{
|
|
dst0[n] = 0.f;
|
|
dst1[n] = 0.f;
|
|
}
|
|
|
|
for( k = 0; k < kmax; k += 4 )
|
|
{
|
|
float alpha00 = aptr0[k];
|
|
float alpha01 = aptr1[k];
|
|
float alpha10 = 0.f, alpha11 = 0.f;
|
|
float alpha20 = 0.f, alpha21 = 0.f;
|
|
float alpha30 = 0.f, alpha31 = 0.f;
|
|
const float* bptr0 = bptr + k*bstep;
|
|
const float* bptr1 = bptr0;
|
|
const float* bptr2 = bptr0;
|
|
const float* bptr3 = bptr0;
|
|
|
|
if( k+1 < kmax )
|
|
{
|
|
alpha10 = aptr0[k+1];
|
|
alpha11 = aptr1[k+1];
|
|
bptr1 = bptr0 + bstep;
|
|
if( k+2 < kmax )
|
|
{
|
|
alpha20 = aptr0[k+2];
|
|
alpha21 = aptr1[k+2];
|
|
bptr2 = bptr1 + bstep;
|
|
if( k+3 < kmax )
|
|
{
|
|
alpha30 = aptr0[k+3];
|
|
alpha31 = aptr1[k+3];
|
|
bptr3 = bptr2 + bstep;
|
|
}
|
|
}
|
|
}
|
|
n = 0;
|
|
|
|
#if CV_SIMD128
|
|
v_float32x4 a00 = v_setall_f32(alpha00);
|
|
v_float32x4 a01 = v_setall_f32(alpha01);
|
|
v_float32x4 a10 = v_setall_f32(alpha10);
|
|
v_float32x4 a11 = v_setall_f32(alpha11);
|
|
v_float32x4 a20 = v_setall_f32(alpha20);
|
|
v_float32x4 a21 = v_setall_f32(alpha21);
|
|
v_float32x4 a30 = v_setall_f32(alpha30);
|
|
v_float32x4 a31 = v_setall_f32(alpha31);
|
|
|
|
for( ; n <= nmax - 4; n += 4 )
|
|
{
|
|
v_float32x4 b0 = v_load(bptr0 + n);
|
|
v_float32x4 b1 = v_load(bptr1 + n);
|
|
v_float32x4 b2 = v_load(bptr2 + n);
|
|
v_float32x4 b3 = v_load(bptr3 + n);
|
|
v_float32x4 d0 = v_load(dst0 + n);
|
|
v_float32x4 d1 = v_load(dst1 + n);
|
|
d0 += b0*a00;
|
|
d1 += b0*a01;
|
|
d0 += b1*a10;
|
|
d1 += b1*a11;
|
|
d0 += b2*a20;
|
|
d1 += b2*a21;
|
|
d0 += b3*a30;
|
|
d1 += b3*a31;
|
|
v_store(dst0 + n, d0);
|
|
v_store(dst1 + n, d1);
|
|
}
|
|
#endif
|
|
|
|
for( ; n < nmax; n++ )
|
|
{
|
|
float b0 = bptr0[n], b1 = bptr1[n];
|
|
float b2 = bptr2[n], b3 = bptr3[n];
|
|
float d0 = dst0[n] + alpha00*b0 + alpha10*b1 + alpha20*b2 + alpha30*b3;
|
|
float d1 = dst1[n] + alpha01*b0 + alpha11*b1 + alpha21*b2 + alpha31*b3;
|
|
dst0[n] = d0;
|
|
dst1[n] = d1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const Mat *a_, *b_;
|
|
Mat* c_;
|
|
int nstripes_;
|
|
bool useAVX;
|
|
bool useAVX2;
|
|
bool useAVX512;
|
|
};
|
|
|
|
class Col2ImInvoker : public cv::ParallelLoopBody
|
|
{
|
|
public:
|
|
const float* data_col;
|
|
const float* biasvec;
|
|
int channels, height, width;
|
|
int kernel_h, kernel_w;
|
|
int pad_h, pad_w;
|
|
int stride_h, stride_w;
|
|
float* data_im;
|
|
int height_col, width_col;
|
|
int nstripes;
|
|
bool is1x1;
|
|
|
|
Col2ImInvoker()
|
|
: data_col(0), biasvec(0), channels(0), height(0), width(0),
|
|
kernel_h(0), kernel_w(0), pad_h(0), pad_w(0), stride_h(0), stride_w(0), data_im(0),
|
|
height_col(0), width_col(0), nstripes(0), is1x1(0)
|
|
{}
|
|
|
|
static void run(const float* data_col,
|
|
int channels, int height, int width,
|
|
int kernel_h, int kernel_w,
|
|
int pad_h, int pad_w,
|
|
int stride_h, int stride_w,
|
|
float* data_im,
|
|
const float* biasvec,
|
|
bool is1x1)
|
|
{
|
|
const int nstripes = getNumThreads();
|
|
|
|
Col2ImInvoker t;
|
|
t.data_col = data_col;
|
|
t.data_im = data_im;
|
|
t.channels = channels; t.height = height; t.width = width;
|
|
t.kernel_h = kernel_h; t.kernel_w = kernel_w;
|
|
t.pad_h = pad_h; t.pad_w = pad_w;
|
|
t.stride_h = stride_h; t.stride_w = stride_w;
|
|
t.height_col = (height + 2 * pad_h - kernel_h) / stride_h + 1;
|
|
t.width_col = (width + 2 * pad_w - kernel_w) / stride_w + 1;
|
|
t.nstripes = nstripes;
|
|
t.is1x1 = is1x1;
|
|
t.biasvec = biasvec;
|
|
|
|
parallel_for_(Range(0, nstripes), t, nstripes);
|
|
}
|
|
|
|
virtual void operator ()(const Range &r) const
|
|
{
|
|
const float* data_col_ = data_col;
|
|
float* data_im_ = data_im;
|
|
int coeff_h = (1 - stride_h * kernel_w * height_col) * width_col;
|
|
int coeff_w = (1 - stride_w * height_col * width_col);
|
|
size_t total = (size_t)channels * height * width;
|
|
size_t stripeSize = (total + nstripes - 1)/nstripes;
|
|
size_t startIndex = r.start*stripeSize;
|
|
size_t endIndex = std::min(r.end*stripeSize, total);
|
|
int w = (int)(startIndex % width + pad_w);
|
|
int h = (int)((startIndex / width) % height + pad_h);
|
|
int c = (int)(startIndex / (width * height));
|
|
int h_col_start = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1;
|
|
int h_col_end = std::min(h / stride_h + 1, height_col);
|
|
int plane_size_col = height_col * width_col;
|
|
int offset = (c * kernel_h * kernel_w + h * kernel_w + w) * plane_size_col;
|
|
bool is1x1_ = is1x1;
|
|
const float* biasvec_ = biasvec;
|
|
|
|
for (size_t index = startIndex; index < endIndex; index++)
|
|
{
|
|
// compute the start and end of the output
|
|
int w_col_start = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1;
|
|
int w_col_end = std::min(w / stride_w + 1, width_col);
|
|
float val;
|
|
|
|
if( is1x1_ )
|
|
val = data_im_[index];
|
|
else
|
|
{
|
|
val = 0.f;
|
|
for (int h_col = h_col_start; h_col < h_col_end; ++h_col) {
|
|
for (int w_col = w_col_start; w_col < w_col_end; ++w_col) {
|
|
val += data_col_[offset + h_col * coeff_h + w_col * coeff_w];
|
|
}
|
|
}
|
|
}
|
|
data_im_[index] = val + biasvec_[c];
|
|
|
|
offset += plane_size_col;
|
|
if( ++w >= width + pad_w )
|
|
{
|
|
w = (int)((index + 1)% width + pad_w);
|
|
h = (int)(((index + 1) / width) % height + pad_h);
|
|
c = (int)((index + 1) / (width * height));
|
|
h_col_start = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1;
|
|
h_col_end = std::min(h / stride_h + 1, height_col);
|
|
offset = (c * kernel_h * kernel_w + h * kernel_w + w) * plane_size_col;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
#ifdef HAVE_OPENCL
|
|
bool forward_ocl(InputArrayOfArrays inputs_, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_)
|
|
{
|
|
std::vector<UMat> inputs;
|
|
std::vector<UMat> outputs;
|
|
std::vector<UMat> internals;
|
|
|
|
inputs_.getUMatVector(inputs);
|
|
outputs_.getUMatVector(outputs);
|
|
internals_.getUMatVector(internals);
|
|
|
|
int outCn = numOutput;
|
|
int inpCn = inputs[0].size[1];
|
|
|
|
if (is1x1())
|
|
return false;
|
|
|
|
if (umat_weights.empty())
|
|
{
|
|
transpose(blobs[0].reshape(1, inpCn), umat_weights);
|
|
umat_biases = hasBias() ? blobs[1].reshape(1, outCn).getUMat(ACCESS_READ) :
|
|
UMat::zeros(outCn, 1, CV_32F);
|
|
}
|
|
|
|
String buildopt = format("-DT=%s ", ocl::typeToStr(inputs[0].type()));
|
|
buildopt += format("-DPAD_H=%d -DPAD_W=%d -DKERNEL_H=%d -DKERNEL_W=%d -DSTRIDE_H=%d -DSTRIDE_W=%d ",
|
|
pad.height, pad.width, kernel.height, kernel.width, stride.height, stride.width);
|
|
|
|
for (size_t ii = 0; ii < outputs.size(); ii++)
|
|
{
|
|
int ngroups = outCn / blobs[0].size[1];
|
|
int inpGroupCn = inpCn / ngroups;
|
|
int outGroupCn = blobs[0].size[1];
|
|
const UMat& inp = inputs[ii];
|
|
UMat& out = outputs[ii];
|
|
int numImg = inp.size[0];
|
|
int inpH = inp.size[2], inpW = inp.size[3];
|
|
int outH = out.size[2], outW = out.size[3];
|
|
|
|
MatShape inpshape = shape(numImg*inpCn, inpH*inpW);
|
|
MatShape outshape = shape(numImg*outCn, outH*outW);
|
|
UMat convBlob = inputs[ii].reshape(1, inpshape.size(), &inpshape[0]);
|
|
UMat decnBlob = out.reshape(1, outshape.size(), &outshape[0]);
|
|
int rows = internals[0].rows / ngroups;
|
|
|
|
for (int n = 0; n < numImg; n++)
|
|
{
|
|
for (int g = 0; g < ngroups; g++)
|
|
{
|
|
UMat colMat = internals[0].rowRange(_Range(g * rows, rows));
|
|
UMat convMat = convBlob.rowRange(_Range((g + n * ngroups) * inpGroupCn, inpGroupCn));
|
|
UMat wghtMat = umat_weights.colRange(_Range(g * inpGroupCn, inpGroupCn));
|
|
gemm(wghtMat, convMat, 1, noArray(), 0, colMat, 0);
|
|
}
|
|
|
|
for (int g = 0; g < ngroups; g++)
|
|
{
|
|
int total = outGroupCn * decnBlob.cols;
|
|
int index = 0;
|
|
int height_col = (outH + 2 * pad.height - kernel.height) / stride.height + 1;
|
|
int width_col = (outW + 2 * pad.width - kernel.width) / stride.width + 1;
|
|
int coeff_h = (1 - stride.height * kernel.width * height_col) * width_col;
|
|
int coeff_w = (1 - stride.width * height_col * width_col);
|
|
|
|
ocl::Kernel k("col2im", ocl::dnn::col2im_oclsrc, buildopt);
|
|
k.set(index++, total);
|
|
k.set(index++, ocl::KernelArg::PtrReadOnly(internals[0]));
|
|
k.set(index++, (int)(g * rows * internals[0].cols));
|
|
k.set(index++, outGroupCn);
|
|
k.set(index++, outH);
|
|
k.set(index++, outW);
|
|
k.set(index++, height_col);
|
|
k.set(index++, width_col);
|
|
k.set(index++, coeff_h);
|
|
k.set(index++, coeff_w);
|
|
k.set(index++, ocl::KernelArg::PtrReadOnly(umat_biases));
|
|
k.set(index++, (int)(g * outGroupCn * umat_biases.cols));
|
|
k.set(index++, ocl::KernelArg::PtrWriteOnly(decnBlob));
|
|
k.set(index++, (int)((g + n * ngroups) * outGroupCn * decnBlob.cols));
|
|
|
|
size_t global[] = { (size_t)total };
|
|
bool ret = k.run(1, global, NULL, false);
|
|
if (!ret)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr)
|
|
{
|
|
CV_TRACE_FUNCTION();
|
|
CV_TRACE_ARG_VALUE(name, "name", name.c_str());
|
|
|
|
CV_OCL_RUN((preferableTarget == DNN_TARGET_OPENCL) &&
|
|
OCL_PERFORMANCE_CHECK(ocl::Device::getDefault().isIntel()),
|
|
forward_ocl(inputs_arr, outputs_arr, internals_arr))
|
|
|
|
Layer::forward_fallback(inputs_arr, outputs_arr, internals_arr);
|
|
}
|
|
|
|
void forward(std::vector<Mat *> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals)
|
|
{
|
|
CV_TRACE_FUNCTION();
|
|
CV_TRACE_ARG_VALUE(name, "name", name.c_str());
|
|
|
|
int outCn = numOutput;
|
|
int inpCn = inputs[0]->size[1];
|
|
bool is1x1flag = is1x1();
|
|
int nstripes = getNumThreads();
|
|
|
|
if( weightsMat.empty() )
|
|
{
|
|
transpose(blobs[0].reshape(1, inpCn), weightsMat);
|
|
biasesMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat::zeros(outCn, 1, CV_32F);
|
|
}
|
|
|
|
for (size_t ii = 0; ii < outputs.size(); ii++)
|
|
{
|
|
int ngroups = outCn / blobs[0].size[1];
|
|
int inpGroupCn = inpCn / ngroups;
|
|
int outGroupCn = blobs[0].size[1];
|
|
const Mat& inp = *inputs[ii];
|
|
Mat& out = outputs[ii];
|
|
int numImg = inp.size[0];
|
|
int outH = out.size[2], outW = out.size[3];
|
|
|
|
Mat convBlob = inputs[ii]->reshape(1, numImg*inpCn);
|
|
Mat decnBlob = out.reshape(1, numImg*outCn);
|
|
|
|
for (int n = 0; n < numImg; n++)
|
|
{
|
|
for (int g = 0; g < ngroups; g++)
|
|
{
|
|
Mat dstMat = decnBlob.rowRange(_Range((g + n * ngroups) * outGroupCn, outGroupCn));
|
|
Mat &colMat = is1x1flag ? dstMat : internals[0];
|
|
|
|
Mat convMat = convBlob.rowRange(_Range((g + n * ngroups) * inpGroupCn, inpGroupCn));
|
|
Mat wghtMat = weightsMat.colRange(_Range(g * inpGroupCn, inpGroupCn));
|
|
Mat curBiasMat = biasesMat.rowRange(_Range(g * outGroupCn, outGroupCn));
|
|
|
|
//gemm(wghtMat, convMat, 1, colMat, 0, colMat, 0);
|
|
MatMulInvoker mminvoker(wghtMat, convMat, colMat, nstripes);
|
|
parallel_for_(Range(0, nstripes), mminvoker, nstripes);
|
|
|
|
Col2ImInvoker::run(colMat.ptr<float>(), outGroupCn, outH, outW,
|
|
kernel.height, kernel.width, pad.height, pad.width,
|
|
stride.height, stride.width, dstMat.ptr<float>(),
|
|
curBiasMat.ptr<float>(), is1x1flag);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs)
|
|
{
|
|
#ifdef HAVE_HALIDE
|
|
Halide::Buffer<float> inputBuffer = halideBuffer(inputs[0]);
|
|
|
|
int inW, inH, inC, inN;
|
|
getCanonicalSize(inputBuffer, &inW, &inH, &inC, &inN);
|
|
const int outGroupCn = blobs[0].size[1];
|
|
const int group = numOutput / outGroupCn;
|
|
const int inpGroupCn = blobs[0].size[0] / group;
|
|
|
|
Halide::Var x("x"), y("y"), c("c"), n("n");
|
|
Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name));
|
|
Halide::Func padded_input(name + "_constant_exterior");
|
|
auto weights = wrapToHalideBuffer(blobs[0]);
|
|
|
|
Halide::Func dilated_input("dilated_input");
|
|
dilated_input(x, y, c, n) = 0.0f;
|
|
Halide::RDom r1(0, inW, 0, inH);
|
|
dilated_input(r1.x * stride.width, r1.y * stride.height, c, n) =
|
|
inputBuffer(r1.x, r1.y, c, n);
|
|
dilated_input.compute_root();
|
|
|
|
Halide::Func bounded =
|
|
Halide::BoundaryConditions::constant_exterior(dilated_input, 0,
|
|
0, (inW - 1) * stride.width + 1,
|
|
0, (inH - 1) * stride.height + 1,
|
|
0, inC, 0, inN);
|
|
padded_input(x, y, c, n) = bounded(x, y, c, n);
|
|
|
|
Halide::RDom r(0, kernel.width, 0, kernel.height, 0, inpGroupCn);
|
|
Halide::Expr kx = x + pad.width - r.x;
|
|
Halide::Expr ky = y + pad.height - r.y;
|
|
Halide::Expr kInC = r.z;
|
|
Halide::Expr kOutC = c;
|
|
for (int i = 1; i < group; ++i)
|
|
{
|
|
kInC = select(c < outGroupCn * i, kInC, inpGroupCn * i + r.z);
|
|
kOutC = select(c < outGroupCn * i, kOutC, c - outGroupCn * i);
|
|
}
|
|
Halide::Expr topExpr = sum(padded_input(kx, ky, kInC, n) *
|
|
weights(r.x, r.y, kOutC, kInC));
|
|
if (hasBias())
|
|
{
|
|
auto bias = wrapToHalideBuffer(blobs[1], {numOutput});
|
|
topExpr += bias(c);
|
|
}
|
|
top(x, y, c, n) = topExpr;
|
|
return Ptr<BackendNode>(new HalideBackendNode({ padded_input, top }));
|
|
#endif // HAVE_HALIDE
|
|
return Ptr<BackendNode>();
|
|
}
|
|
|
|
virtual int64 getFLOPS(const std::vector<MatShape> &inputs,
|
|
const std::vector<MatShape> &outputs) const
|
|
{
|
|
CV_Assert(inputs.size() == outputs.size());
|
|
|
|
float flops = 0;
|
|
int outChannels = blobs[0].size[0];
|
|
|
|
for (int i = 0; i < inputs.size(); i++)
|
|
{
|
|
flops += CV_BIG_INT(2)*outChannels*kernel.area()*total(inputs[i]);
|
|
}
|
|
|
|
return flops;
|
|
}
|
|
};
|
|
|
|
//Convolution and Deconvolution
|
|
static void initConvDeconvLayerFromCaffe(Ptr<BaseConvolutionLayer> l, const LayerParams ¶ms)
|
|
{
|
|
l->setParamsFrom(params);
|
|
getConvolutionKernelParams(params, l->kernel.height, l->kernel.width, l->pad.height,
|
|
l->pad.width, l->stride.height, l->stride.width, l->dilation.height,
|
|
l->dilation.width, l->padMode);
|
|
|
|
l->numOutput = params.get<int>("num_output");
|
|
int ngroups = params.get<int>("group", 1);
|
|
|
|
l->adjustPad.height = params.get<int>("adj_h", 0);
|
|
l->adjustPad.width = params.get<int>("adj_w", 0);
|
|
|
|
CV_Assert(l->numOutput % ngroups == 0);
|
|
CV_Assert(l->adjustPad.width < l->stride.width &&
|
|
l->adjustPad.height < l->stride.height);
|
|
}
|
|
|
|
Ptr<BaseConvolutionLayer> ConvolutionLayer::create(const LayerParams ¶ms)
|
|
{
|
|
ConvolutionLayerImpl* conv_ptr = new ConvolutionLayerImpl;
|
|
Ptr<BaseConvolutionLayer> l(conv_ptr);
|
|
initConvDeconvLayerFromCaffe(l, params);
|
|
|
|
#ifdef HAVE_OPENCL
|
|
size_t n = params.blobs.size();
|
|
conv_ptr->umat_blobs.resize(n);
|
|
for (int i = 0; i < n; i++)
|
|
conv_ptr->umat_blobs[i] = params.blobs[i].getUMat(ACCESS_READ);
|
|
#endif
|
|
|
|
return l;
|
|
}
|
|
|
|
Ptr<BaseConvolutionLayer> DeconvolutionLayer::create(const LayerParams ¶ms)
|
|
{
|
|
Ptr<BaseConvolutionLayer> l(new DeConvolutionLayerImpl);
|
|
initConvDeconvLayerFromCaffe(l, params);
|
|
|
|
return l;
|
|
}
|
|
|
|
}
|
|
}
|