{

BaseConvolutionLayerImpl() {}

virtual bool supportBackend(int backendId)

{

return backendId == DNN_BACKEND_DEFAULT ||

backendId == DNN_BACKEND_HALIDE && haveHalide();

}

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

}

{

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;

}

}

#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)

{

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 !scaleLayer.empty();

}

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>();

}

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);

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

{

convolutionOp->setActivReLU(false, 0);

convolutionOp->setActivPReLU(false, reluslope);

convolutionOp->setActivPower(false, 1.f);

}

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",

CV_Assert(inputs.size() == (size_t)1 && inputs[0]->size[1] % blobs[0].size[1] == 0);

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();